text
stringlengths 0
3.34M
|
|---|
module DATA_MODULE
use Constants
type CHAR_DATA
character(len=MAX_NLEN) :: value
end type CHAR_DATA
type(CHAR_DATA), parameter :: empty_data=CHAR_DATA('')
end module DATA_MODULE
module vararray
use DATA_MODULE, LIST_DATA=>CHAR_DATA, &
empty_list_data=>empty_data
! lists.f90
! Implementation of dynamically growing arrays
!
! Basically this is Arjen Markus's vector.f90 module but I have
! renamed it from vector to lists, because most scientists don't
! care about fine distinctions between "linked lists" and C++-type
! "vectors" and this object behaves like a Python/Perl/etc. list.
!
! The module is straightforward: it defines a suitable
! data structure, data can be added to the list
! and you can retrieve data from it.
!
! Note:
! For the function list_at() we need a parameter
! that represents the "empty list data" value.
!
! $Id: vectors.f90,v 1.4 2008/06/12 15:12:39 relaxmike Exp $
!
! Written by Arjen Markus
type LIST
private
integer :: not_used
type(LIST_DATA), dimension(:), pointer :: data => null()
end type list
private
public :: LIST
public :: LIST_DATA
public :: list_create
public :: list_append
public :: list_at
public :: list_size
public :: list_put
public :: list_delete_elements
public :: list_destroy
public :: list_insert_empty
real, parameter :: growth_rate = 1.1
contains
! list_create
! Create a new list
!
! Arguments:
! lst Variable that should hold the list
! capacity Initial capacity (optional)
!
! Note:
! The fields of the list data structure are set
!
subroutine list_create( lst, capacity )
type(LIST) :: lst
integer, optional :: capacity
integer :: cap
!
! Check that the list does not have any data left
!
if ( associated(lst%data) ) then
call list_destroy( lst )
endif
if ( present(capacity) ) then
cap = max( 1, capacity )
else
cap = 10
endif
allocate( lst%data(1:cap) )
lst%not_used = 0
end subroutine list_create
! list_destroy
! Destroy a list
!
! Arguments:
! lst list in question
!
subroutine list_destroy( lst )
type(LIST) :: lst
!
! Check that the list does not have any data left
!
if ( associated(lst%data) ) then
deallocate( lst%data )
endif
lst%not_used = 0
end subroutine list_destroy
! list_size
! Return the number of elements in use
!
! Arguments:
! lst Variable that holds the list
!
integer function list_size( lst )
type(LIST) :: lst
list_size = lst%not_used
end function list_size
! list_at
! Get the value of the nth element of the list
!
! Arguments:
! lst list in question
! n Index of the element whose value
! should be retrieved
!
type(LIST_DATA) function list_at( lst, n )
type(LIST) :: lst
integer :: n
if ( n .lt. 1 .or. n .gt. lst%not_used ) then
list_at = empty_list_data
else
list_at = lst%data(n)
endif
end function list_at
! list_insert_empty
! Insert one or more empty elements
!
! Arguments:
! list list in question
! pos Position to insert the empty elements
! number Number of empty elements
!
subroutine list_insert_empty( lst, pos, number )
type(LIST) :: lst
integer, intent(in) :: pos
integer, intent(in) :: number
integer :: i
if ( number .lt. 1 .or. pos .lt. 1 .or. pos .gt. lst%not_used ) then
return
endif
if ( lst%not_used+number .ge. size(lst%data) ) then
call list_increase_capacity( lst, lst%not_used+number )
endif
do i = lst%not_used,pos,-1
lst%data(i+number) = lst%data(i)
enddo
do i = 1,number
lst%data(pos+i-1) = empty_list_data
enddo
lst%not_used = lst%not_used + number
end subroutine list_insert_empty
! list_delete_elements
! Delete one or more elements
!
! Arguments:
! list list in question
! pos Position to start deletion
! number Number of elements
!
subroutine list_delete_elements( lst, pos, number )
type(LIST) :: lst
integer, intent(in) :: pos
integer, intent(in) :: number
integer :: i
if ( number .lt. 1 .or. pos .lt. 1 .or. pos .gt. lst%not_used ) then
return
endif
do i = pos,lst%not_used-number
lst%data(i) = lst%data(i+number)
enddo
lst%not_used = lst%not_used - number
end subroutine list_delete_elements
! list_append
! Append a value to the list
!
! Arguments:
! lst list in question
! data Data to be appended
!
subroutine list_append( lst, data )
type(LIST) :: lst
type(LIST_DATA) :: data
if ( lst%not_used .ge. size(lst%data) ) then
call list_increase_capacity( lst, lst%not_used+1 )
endif
lst%not_used = lst%not_used + 1
lst%data(lst%not_used) = data
end subroutine list_append
! list_put
! Put a value at a specific element of the list
! (it needs not yet exist)
!
! Arguments:
! lst list in question
! n Index of the element
! data Data to be put in the list
!
subroutine list_put( lst, n, data )
type(LIST) :: lst
integer :: n
type(LIST_DATA) :: data
if ( n .lt. 1 ) then
return
endif
if ( n .gt. size(lst%data) ) then
call list_increase_capacity( lst, n )
endif
lst%not_used = max( lst%not_used, n)
lst%data(n) = data
end subroutine list_put
! list_increase_capacity
! Expand the array holding the data
!
! Arguments:
! lst list in question
! capacity Minimum capacity
!
subroutine list_increase_capacity( lst, capacity )
type(LIST) :: lst
integer :: capacity
integer :: new_cap
type(LIST_DATA), dimension(:), pointer :: new_data
new_cap = max( capacity, nint( growth_rate * size(lst%data) ) )
if ( new_cap .gt. size(lst%data) ) then
allocate( new_data(1:new_cap) )
new_data(1:lst%not_used) = lst%data(1:lst%not_used)
new_data(lst%not_used+1:new_cap) = empty_list_data
deallocate( lst%data )
lst%data => new_data
endif
end subroutine list_increase_capacity
end module vararray
|
\chapter{Introduction}
\paragraph{Target Audience}
This document is meant for C++ programmers.
\paragraph{Motivation}
Remember the realtime CG days in the previous millennium where a nose of a character consisted of just three triangles? Well, this were the days were rendering a scene was mostly about rastering the triangles, meshes are made up of. Nowadays, rastering mesh triangles is just a part of the complete rendering process. The final image you see on your screen is the result of many compositing steps - just like movies with tons of special effects produce the final image by compositing multiple image layers. The \emph{PLCompositing} component is the place were the compositing steps within the PixelLight framework are implemented. While the scene graph is a representation of the scene - the data, the task of the scene rendering and compositing system is to take the scene graph and all assigned data and bring them onto the computer monitor in the best way possible. For legacy hardware, this scene rendering may just mean to render the scene using simple textures - for decent hardware the scene may be rendered using dynamic lighting and shadowing as well as tons of used special effects like normal mapping, \ac{SSAO}, \ac{HDR} and so on.
\section{External Dependences}
PLCompositing depends on the \textbf{PLCore}, \textbf{PLMath}, \textbf{PLGraphics}, \textbf{PLRenderer}, \textbf{PLMesh} and \textbf{PLScene} libraries.
|
-- SPDX-FileCopyrightText: 2021 The toml-idr developers
--
-- SPDX-License-Identifier: MPL-2.0
module Language.TOML.Tokens
import Text.Token
%default total
public export
strTrue : String
strTrue = "true"
public export
strFalse : String
strFalse = "false"
public export
data Bracket = Open | Close
public export
Eq Bracket where
(==) Open Open = True
(==) Close Close = True
(==) _ _ = False
public export
data Punctuation
= Comma
| Dot
| Equal
| NewLine
| Square Bracket
| Curly Bracket
public export
Eq Punctuation where
(==) Comma Comma = True
(==) Dot Dot = True
(==) Equal Equal = True
(==) NewLine NewLine = True
(==) (Square x) (Square y) = x == y
(==) (Curly x) (Curly y) = x == y
(==) _ _ = False
public export
data TOMLTokenKind
= TTBoolean
| TTInt
| TTFloat
| TTString
| TTPunct Punctuation
| TTBare
| TTIgnored
public export
TOMLToken : Type
TOMLToken = Token TOMLTokenKind
public export
Eq TOMLTokenKind where
(==) TTBoolean TTBoolean = True
(==) TTInt TTInt = True
(==) TTFloat TTFloat = True
(==) TTString TTString = True
(==) (TTPunct x) (TTPunct y) = x == y
(==) TTBare TTBare = True
(==) TTIgnored TTIgnored = True
(==) _ _ = False
public export
TokenKind TOMLTokenKind where
TokType TTBoolean = Bool
TokType TTInt = Integer
TokType TTFloat = Double
TokType TTString = String
TokType (TTPunct _) = ()
TokType TTBare = String
TokType TTIgnored = ()
tokValue TTBoolean s = s == strTrue
tokValue TTInt s = cast s
tokValue TTFloat s = cast s
tokValue TTString s = s -- TODO "unescape" the string
tokValue (TTPunct _) _ = ()
tokValue TTBare s = s
tokValue TTIgnored _ = ()
export
ignored : TOMLToken -> Bool
ignored (Tok TTIgnored _) = True
ignored _ = False |
module Idris.ProcessIdr
import Compiler.Inline
import Core.Binary
import Core.Context
import Core.Context.Log
import Core.Directory
import Core.Env
import Core.Hash
import Core.Metadata
import Core.Options
import Core.Unify
import Parser.Unlit
import TTImp.Elab.Check
import TTImp.ProcessDecls
import TTImp.TTImp
import Idris.Desugar
import Idris.Parser
import Idris.REPLCommon
import Idris.REPLOpts
import Idris.Syntax
import Idris.Pretty
import Data.List
import Data.NameMap
import System.File
%default covering
processDecl : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto m : Ref MD Metadata} ->
PDecl -> Core (Maybe Error)
processDecl decl
= catch (do impdecls <- desugarDecl [] decl
traverse (Check.processDecl [] (MkNested []) []) impdecls
pure Nothing)
(\err => do giveUpConstraints -- or we'll keep trying...
pure (Just err))
processDecls : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto m : Ref MD Metadata} ->
List PDecl -> Core (List Error)
processDecls decls
= do xs <- traverse processDecl decls
Nothing <- checkDelayedHoles
| Just err => pure (case mapMaybe id xs of
[] => [err]
errs => errs)
errs <- getTotalityErrors
pure (mapMaybe id xs ++ errs)
export
readModule : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
(full : Bool) -> -- load everything transitively (needed for REPL and compiling)
FC ->
(visible : Bool) -> -- Is import visible to top level module?
(imp : ModuleIdent) -> -- Module name to import
(as : Namespace) -> -- Namespace to import into
Core ()
readModule full loc vis imp as
= do defs <- get Ctxt
let False = (imp, vis, as) `elem` map snd (allImported defs)
| True => when vis (setVisible (miAsNamespace imp))
Right fname <- nsToPath loc imp
| Left err => throw err
Just (syn, hash, more) <- readFromTTC False {extra = SyntaxInfo}
loc vis fname imp as
| Nothing => when vis (setVisible (miAsNamespace imp)) -- already loaded, just set visibility
extendSyn syn
defs <- get Ctxt
modNS <- getNS
when vis $ setVisible (miAsNamespace imp)
traverse_ (\ mimp =>
do let m = fst mimp
let reexp = fst (snd mimp)
let as = snd (snd mimp)
when (reexp || full) $ readModule full loc reexp m as) more
setNS modNS
readImport : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
Bool -> Import -> Core ()
readImport full imp
= do readModule full (loc imp) True (path imp) (nameAs imp)
addImported (path imp, reexport imp, nameAs imp)
||| Adds new import to the namespace without changing the current top-level namespace
export
addImport : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
Import -> Core ()
addImport imp
= do topNS <- getNS
readImport True imp
setNS topNS
readHash : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
Import -> Core (Bool, (Namespace, Int))
readHash imp
= do Right fname <- nsToPath (loc imp) (path imp)
| Left err => throw err
h <- readIFaceHash fname
pure (reexport imp, (nameAs imp, h))
prelude : Import
prelude = MkImport (MkFC "(implicit)" (0, 0) (0, 0)) False
(nsAsModuleIdent preludeNS) preludeNS
export
readPrelude : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
Bool -> Core ()
readPrelude full
= do readImport full prelude
setNS mainNS
-- Import a TTC for use as the main file (e.g. at the REPL)
export
readAsMain : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
(fname : String) -> Core ()
readAsMain fname
= do Just (syn, _, more) <- readFromTTC {extra = SyntaxInfo}
True toplevelFC True fname (nsAsModuleIdent emptyNS) emptyNS
| Nothing => throw (InternalError "Already loaded")
replNS <- getNS
replNestedNS <- getNestedNS
extendSyn syn
-- Read the main file's top level imported modules, so we have access
-- to their names (and any of their public imports)
ustm <- get UST
traverse_ (\ mimp =>
do let m = fst mimp
let as = snd (snd mimp)
readModule True emptyFC True m as
addImported (m, True, as)) more
-- also load the prelude, if required, so that we have access to it
-- at the REPL.
when (not (noprelude !getSession)) $
readModule True emptyFC True (nsAsModuleIdent preludeNS) preludeNS
-- We're in the namespace from the first TTC, so use the next name
-- from that for the fresh metavariable name generation
-- TODO: Maybe we should record this per namespace, since this is
-- a little bit of a hack? Or maybe that will have too much overhead.
ust <- get UST
put UST (record { nextName = nextName ustm } ust)
setNS replNS
setNestedNS replNestedNS
addPrelude : List Import -> List Import
addPrelude imps
= if not (nsAsModuleIdent preludeNS `elem` map path imps)
then prelude :: imps
else imps
-- Get a file's modified time. If it doesn't exist, return 0 (that is, it
-- was last modified at the dawn of time so definitely out of date for
-- rebuilding purposes...)
modTime : String -> Core Integer
modTime fname
= do Right f <- coreLift $ openFile fname Read
| Left err => pure 0 -- Beginning of Time :)
Right t <- coreLift $ fileModifiedTime f
| Left err => do coreLift $ closeFile f
pure 0
coreLift $ closeFile f
pure (cast t)
export
getParseErrorLoc : String -> ParseError Token -> FC
getParseErrorLoc fname (ParseFail _ (Just pos) _) = MkFC fname pos pos
getParseErrorLoc fname (LexFail (l, c, _)) = MkFC fname (l, c) (l, c)
getParseErrorLoc fname (LitFail (MkLitErr l c _)) = MkFC fname (l, 0) (l, 0)
getParseErrorLoc fname _ = replFC
export
readHeader : {auto c : Ref Ctxt Defs} ->
(path : String) -> Core Module
readHeader path
= do Right res <- coreLift (readFile path)
| Left err => throw (FileErr path err)
case runParserTo (isLitFile path) isColon res (progHdr path) of
Left err => throw (ParseFail (getParseErrorLoc path err) err)
Right mod => pure mod
where
-- Stop at the first :, that's definitely not part of the header, to
-- save lexing the whole file unnecessarily
isColon : WithBounds Token -> Bool
isColon t
= case t.val of
Symbol ":" => True
_ => False
%foreign "scheme:collect"
prim__gc : Int -> PrimIO ()
gc : IO ()
gc = primIO $ prim__gc 4
export
addPublicHash : {auto c : Ref Ctxt Defs} ->
(Bool, (Namespace, Int)) -> Core ()
addPublicHash (True, (mod, h)) = do addHash mod; addHash h
addPublicHash _ = pure ()
-- Process everything in the module; return the syntax information which
-- needs to be written to the TTC (e.g. exported infix operators)
-- Returns 'Nothing' if it didn't reload anything
processMod : {auto c : Ref Ctxt Defs} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto m : Ref MD Metadata} ->
{auto o : Ref ROpts REPLOpts} ->
(srcf : String) -> (ttcf : String) -> (msg : Doc IdrisAnn) ->
(sourcecode : String) ->
Core (Maybe (List Error))
processMod srcf ttcf msg sourcecode
= catch (do
setCurrentElabSource sourcecode
-- Just read the header to start with (this is to get the imports and
-- see if we can avoid rebuilding if none have changed)
modh <- readHeader srcf
-- Add an implicit prelude import
let imps =
if (noprelude !getSession || moduleNS modh == nsAsModuleIdent preludeNS)
then imports modh
else addPrelude (imports modh)
hs <- traverse readHash imps
defs <- get Ctxt
log "" 5 $ "Current hash " ++ show (ifaceHash defs)
log "" 5 $ show (moduleNS modh) ++ " hashes:\n" ++
show (sort (map snd hs))
imphs <- readImportHashes ttcf
log "" 5 $ "Old hashes from " ++ ttcf ++ ":\n" ++ show (sort imphs)
-- If the old hashes are the same as the hashes we've just
-- read from the imports, and the source file is older than
-- the ttc, we can skip the rest.
srctime <- modTime srcf
ttctime <- modTime ttcf
let ns = moduleNS modh
if (sort (map snd hs) == sort imphs && srctime <= ttctime)
then -- Hashes the same, source up to date, just set the namespace
-- for the REPL
do setNS (miAsNamespace ns)
pure Nothing
else -- needs rebuilding
do iputStrLn msg
Right mod <- logTime ("++ Parsing " ++ srcf) $
pure (runParser (isLitFile srcf) sourcecode (do p <- prog srcf; eoi; pure p))
| Left err => pure (Just [ParseFail (getParseErrorLoc srcf err) err])
initHash
traverse addPublicHash (sort hs)
resetNextVar
when (ns /= nsAsModuleIdent mainNS) $
do let MkFC fname _ _ = headerloc mod
d <- getDirs
ns' <- pathToNS (working_dir d) (source_dir d) fname
when (ns /= ns') $
throw (GenericMsg (headerloc mod)
("Module name " ++ show ns ++
" does not match file name " ++ fname))
-- read import ttcs in full here
-- Note: We should only import .ttc - assumption is that there's
-- a phase before this which builds the dependency graph
-- (also that we only build child dependencies if rebuilding
-- changes the interface - will need to store a hash in .ttc!)
logTime "++ Reading imports" $
traverse_ (readImport False) imps
-- Before we process the source, make sure the "hide_everywhere"
-- names are set to private (TODO, maybe if we want this?)
-- defs <- get Ctxt
-- traverse (\x => setVisibility emptyFC x Private) (hiddenNames defs)
setNS (miAsNamespace ns)
errs <- logTime "++ Processing decls" $
processDecls (decls mod)
-- coreLift $ gc
logTime "++ Compile defs" $ compileAndInlineAll
-- Save the import hashes for the imports we just read.
-- If they haven't changed next time, and the source
-- file hasn't changed, no need to rebuild.
defs <- get Ctxt
put Ctxt (record { importHashes = map snd hs } defs)
pure (Just errs))
(\err => pure (Just [err]))
-- Process a file. Returns any errors, rather than throwing them, because there
-- might be lots of errors collected across a whole file.
export
process : {auto c : Ref Ctxt Defs} ->
{auto m : Ref MD Metadata} ->
{auto u : Ref UST UState} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto o : Ref ROpts REPLOpts} ->
Doc IdrisAnn -> FileName ->
Core (List Error)
process buildmsg file
= do Right res <- coreLift (readFile file)
| Left err => pure [FileErr file err]
catch (do ttcf <- getTTCFileName file "ttc"
Just errs <- logTime ("+ Elaborating " ++ file) $
processMod file ttcf buildmsg res
| Nothing => pure [] -- skipped it
if isNil errs
then
do defs <- get Ctxt
d <- getDirs
ns <- pathToNS (working_dir d) (source_dir d) file
makeBuildDirectory ns
writeToTTC !(get Syn) ttcf
ttmf <- getTTCFileName file "ttm"
writeToTTM ttmf
pure []
else do pure errs)
(\err => pure [err])
|
import Observables
import AbstractPlotting
q1 = Biquaternion(Quaternion(rand(4)), βΒ³(rand(3)))
scene = AbstractPlotting.Scene()
radius = rand()
segments = rand(5:10)
color = AbstractPlotting.RGBAf0(rand(4)...)
transparency = false
sphere = Sphere(q1,
scene,
radius = radius,
segments = segments,
color = color,
transparency = transparency)
q2 = q1 * Biquaternion(Quaternion(rand(4)), βΒ³(rand(3)))
value1 = getsurface(sphere.observable, segments)
update(sphere, q2)
value2 = getsurface(sphere.observable, segments)
@test isapprox(sphere.q, q2)
@test isapprox(value1, value2) == false
|
141. WALTER11 BRUNT (ELIZABETH10 DERRICK, JOHN9, WILLIAM8, JACOB7,WILLIAM6, WILLIAM5, EDMUND4, EDMUND3, EDMUND2, RICHARD1) was born 11 February 1849 in Blagdon, Som, Eng, and died 1925 in Blagdon, Som, Eng.
He married (1) ELIZA WESTAWAY 1 July 1880 in Dartinton, Dev, Eng.. She was born Abt. 1843, and died Aft. 1884.
He married (2) ALICE EVANS 25 August 1912 in Blagdon, Som, Eng.. She was born 1872 in Timsbury, Som, Eng., and died 1965 in Blagdon, Som, Eng.
i. WALTER WESTAWAY12 BRUNT, b. 1883, London, Eng.; d. Unknown.
ii. OLIVIA WESTAWAY BRUNT, b. 1883, London, Eng.; d. 1883, London, Eng.
174. iii. CHARLES THOMAS12 BRUNT, b. 1913, Blagdon, Som, Eng.; d. 1992, Backwell, Som, Eng. |
REAL FUNCTION SBESY0 (X)
c Copyright (c) 1996 California Institute of Technology, Pasadena, CA.
c ALL RIGHTS RESERVED.
c Based on Government Sponsored Research NAS7-03001.
c>> 1996-03-30 SBESY0 Krogh Added external statement.
C>> 1995-11-13 SBESY0 Krogh Changes to simplify conversion to C.
C>> 1994-11-11 SBESY0 Krogh Declared all vars.
C>> 1994-10-20 SBESY0 Krogh Changes to use M77CON
C>> 1990-11-29 SBESY0 CLL
C>> 1985-08-02 SBESY0 Lawson Initial code.
C JULY 1977 EDITION. W. FULLERTON, C3, LOS ALAMOS SCIENTIFIC LAB.
C C.L.LAWSON & S.CHAN, JPL, 1984 FEB ADAPTED TO JPL MATH77 LIBRARY.
c ------------------------------------------------------------------
c--S replaces "?": ?BESY0, ?BESJ0, ?BMP0, ?INITS, ?CSEVL, ?ERM1
c ------------------------------------------------------------------
EXTERNAL R1MACH, SBESJ0, SCSEVL
INTEGER NTY0
REAL X, BY0CS(19), AMPL, THETA, TWODPI, XSML,
1 Y, R1MACH, SCSEVL, SBESJ0
C
C SERIES FOR BY0 ON THE INTERVAL 0. TO 1.60000E+01
C WITH WEIGHTED ERROR 8.14E-32
C LOG WEIGHTED ERROR 31.09
C SIGNIFICANT FIGURES REQUIRED 30.31
C DECIMAL PLACES REQUIRED 31.73
C
SAVE NTY0, XSML
C
DATA BY0CS / -.1127783939286557321793980546028E-1,
* -.1283452375604203460480884531838E+0,
* -.1043788479979424936581762276618E+0,
* +.2366274918396969540924159264613E-1,
* -.2090391647700486239196223950342E-2,
* +.1039754539390572520999246576381E-3,
* -.3369747162423972096718775345037E-5,
* +.7729384267670667158521367216371E-7,
* -.1324976772664259591443476068964E-8,
* +.1764823261540452792100389363158E-10,
* -.1881055071580196200602823012069E-12,
* +.1641865485366149502792237185749E-14,
* -.1195659438604606085745991006720E-16,
* +.7377296297440185842494112426666E-19,
* -.3906843476710437330740906666666E-21,
* +.1795503664436157949829120000000E-23,
* -.7229627125448010478933333333333E-26,
* +.2571727931635168597333333333333E-28,
* -.8141268814163694933333333333333E-31 /
C
DATA TWODPI / 0.636619772367581343075535053490057E0 /
DATA NTY0, XSML / 0, 0.E0 /
C ------------------------------------------------------------------
IF (NTY0 .eq. 0) then
call SINITS (BY0CS, 19, 0.1E0*R1MACH(3), NTY0)
XSML = SQRT (4.0E0*R1MACH(3))
endif
C
IF (X .LE. 0.E0) THEN
SBESY0 = 0.E0
CALL SERM1 ('SBESY0',1,0,'X IS ZERO OR NEGATIVE','X',X,'.')
ELSE IF (X .LE. 4.E0) THEN
IF (X .LE. XSML) THEN
Y = 0.E0
ELSE
Y = X * X
END IF
SBESY0 = TWODPI*LOG(0.5E0*X)*SBESJ0(X) + .375E0 +
* SCSEVL (.125E0*Y-1.E0, BY0CS, NTY0)
ELSE
CALL SBMP0 (X, AMPL, THETA)
SBESY0 = AMPL * SIN(THETA)
END IF
C
RETURN
C
END
|
C$Procedure DSKI02 ( DSK, fetch integer type 2 data )
SUBROUTINE DSKI02 ( HANDLE, DLADSC, ITEM, START, ROOM, N, VALUES )
C$ Abstract
C
C Fetch integer data from a type 2 DSK segment.
C
C$ Disclaimer
C
C THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE
C CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S.
C GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE
C ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE
C PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS"
C TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY
C WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A
C PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC
C SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
C SOFTWARE AND RELATED MATERIALS, HOWEVER USED.
C
C IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA
C BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT
C LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND,
C INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS,
C REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE
C REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY.
C
C RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF
C THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY
C CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE
C ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE.
C
C$ Required_Reading
C
C DAS
C DSK
C
C$ Keywords
C
C DAS
C DSK
C FILES
C
C$ Declarations
IMPLICIT NONE
INCLUDE 'dla.inc'
INCLUDE 'dskdsc.inc'
INCLUDE 'dsk02.inc'
INTEGER HANDLE
INTEGER DLADSC ( * )
INTEGER ITEM
INTEGER START
INTEGER ROOM
INTEGER N
INTEGER VALUES ( * )
C$ Brief_I/O
C
C Variable I/O Description
C -------- --- --------------------------------------------------
C HANDLE I DSK file handle.
C DLADSC I DLA descriptor.
C ITEM I Keyword identifying item to fetch.
C START I Start index.
C ROOM I Amount of room in output array.
C N O Number of values returned.
C VALUES O Array containing requested item.
C
C$ Detailed_Input
C
C HANDLE is the handle of a DSK file containing a type 2
C segment from which data are to be fetched.
C
C DLADSC is the DLA descriptor associated with the segment
C from which data are to be fetched.
C
C ITEM is an integer "keyword" parameter designating the
C item to fetch. In the descriptions below, note
C that "model" refers to the model represented by
C the designated segment. This model may be a
C subset of a larger model.
C
C Names and meanings of parameters supported by this
C routine are:
C
C KWNV Number of vertices in model.
C
C KWNP Number of plates in model.
C
C KWNVXT Total number of voxels in fine grid.
C
C KWVGRX Voxel grid extent. This extent is
C an array of three integers
C indicating the number of voxels in
C the X, Y, and Z directions in the
C fine voxel grid.
C
C KWCGSC Coarse voxel grid scale. The extent
C of the fine voxel grid is related to
C the extent of the coarse voxel grid
C by this scale factor.
C
C KWVXPS Size of the voxel-to-plate pointer
C list.
C
C KWVXLS Voxel-plate correspondence list size.
C
C KWVTLS Vertex-plate correspondence list
C size.
C
C KWPLAT Plate array. For each plate, this
C array contains the indices of the
C plate's three vertices. The ordering
C of the array members is:
C
C Plate 1 vertex index 1
C Plate 1 vertex index 2
C Plate 1 vertex index 3
C Plate 2 vertex index 1
C ...
C
C KWVXPT Voxel-plate pointer list. This list
C contains pointers that map fine
C voxels to lists of plates that
C intersect those voxels. Note that
C only fine voxels belonging to
C non-empty coarse voxels are in the
C domain of this mapping.
C
C KWVXPL Voxel-plate correspondence list.
C This list contains lists of plates
C that intersect fine voxels. (This
C list is the data structure into
C which the voxel-to-plate pointers
C point.) This list can contain
C empty lists.
C
C KWVTPT Vertex-plate pointer list. This list
C contains pointers that map vertices
C to lists of plates to which those
C vertices belong.
C
C Note that the size of this list is
C always NV, the number of vertices.
C Hence there's no need for a separate
C keyword for the size of this list.
C
C KWVTPL Vertex-plate correspondence list.
C This list contains, for each vertex,
C the indices of the plates to which
C that vertex belongs.
C
C KWCGPT Coarse voxel grid pointers. This is
C an array of pointers mapping coarse
C voxels to lists of pointers in the
C voxel-plate pointer list. Each
C non-empty coarse voxel maps to a
C list of pointers; every fine voxel
C contained in a non-empty coarse voxel
C has its own pointers. Grid elements
C corresponding to empty coarse voxels
C have null (non-positive) pointers.
C
C See the INCLUDE file dsk.inc for values
C associated with the keyword parameters.
C
C
C START is the start index within the specified data item
C from which data are to be fetched. The index of
C the first element of each data item is 1. START
C has units of integers; for example, the start
C index of the second plate is 4, since each plate
C occupies three integers.
C
C ROOM is the amount of room in the output array. It is
C permissible to provide an output array that has
C too little room to fetch an item in one call. ROOM
C has units of integers: for example, the room
C required to fetch one plate is 3.
C
C$ Detailed_Output
C
C N is the number of elements fetched to the output
C array VALUES. N is normally in the range
C 1:ROOM; if an error occurs on the call, N is
C undefined.
C
C VALUES is a contiguous set of elements of the item
C designated by ITEM. The correspondence of
C VALUES at the elements of the data item is:
C
C VALUES(1) ITEM(START)
C ... ...
C VALUES(N) ITEM(START+N-1)
C
C If an error occurs on the call, VALUES is
C undefined.
C
C$ Parameters
C
C See the INCLUDE files
C
C dla.inc
C dsk02.inc
C dskdsc.inc
C
C$ Exceptions
C
C 1) If the input handle is invalid, the error will be diagnosed by
C routines in the call tree of this routine.
C
C 2) If a file read error occurs, the error will be diagnosed by
C routines in the call tree of this routine.
C
C 3) If the input DLA descriptor is invalid, the effect of this
C routine is undefined. The error *may* be diagnosed by routines
C in the call tree of this routine, but there are no
C guarantees.
C
C 4) If ROOM is non-positive, the error SPICE(VALUEOUTOFRANGE)
C is signaled.
C
C 5) If the coarse voxel scale read from the designated segment
C is less than 1, the error SPICE(VALUEOUTOFRANGE) is signaled.
C
C 6) If the input keyword parameter is not recognized, the error
C SPICE(NOTSUPPORTED) is signaled.
C
C 7) If START is less than 1 or greater than the size of the
C item to be fetched, the error SPICE(INDEXOUTOFRANGE) is
C signaled.
C
C$ Files
C
C See input argument HANDLE.
C
C$ Particulars
C
C Most SPICE applications will not need to call this routine. The
C routines DSKV02, DSKP02, and DSKZ02 provide a higher-level
C interface for fetching DSK type 2 vertex and plate data.
C
C DSK files are built using the DLA low-level format and
C the DAS architecture; DLA files are a specialized type of DAS
C file in which data are organized as a doubly linked list of
C segments. Each segment's data belong to contiguous components of
C character, double precision, and integer type.
C
C Note that the DSK descriptor for the segment is not needed by
C this routine; the DLA descriptor contains the base address and
C size information for the integer, double precision, and character
C components of the segment, and these suffice for the purpose of
C fetching data.
C
C$ Examples
C
C The numerical results shown for this example may differ across
C platforms. The results depend on the SPICE kernels used as
C input, the compiler and supporting libraries, and the machine
C specific arithmetic implementation.
C
C 1) Look up all the vertices associated with each plate
C of the model contained in a specified type 2 segment.
C For this example, we'll show the context of this look-up:
C opening the DSK file for read access, traversing a trivial,
C one-segment list to obtain the segment of interest.
C
C
C Example code begins here.
C
C
C PROGRAM EX1
C IMPLICIT NONE
C
C INCLUDE 'dla.inc'
C INCLUDE 'dskdsc.inc'
C INCLUDE 'dsk02.inc'
C
C C
C C Local parameters
C C
C CHARACTER*(*) FMT
C PARAMETER ( FMT = '(1X,A,3(1XE16.9))' )
C
C INTEGER FILSIZ
C PARAMETER ( FILSIZ = 255 )
C
C C
C C Local variables
C C
C CHARACTER*(FILSIZ) DSK
C
C DOUBLE PRECISION VRTCES ( 3, 3 )
C
C INTEGER DLADSC ( DLADSZ )
C INTEGER HANDLE
C INTEGER I
C INTEGER J
C INTEGER N
C INTEGER NP
C INTEGER START
C INTEGER VRTIDS ( 3 )
C
C LOGICAL FOUND
C
C
C C
C C Prompt for the name of the DSK to read.
C C
C CALL PROMPT ( 'Enter DSK name > ', DSK )
C C
C C Open the DSK file for read access.
C C We use the DAS-level interface for
C C this function.
C C
C CALL DASOPR ( DSK, HANDLE )
C
C C
C C Begin a forward search through the
C C kernel, treating the file as a DLA.
C C In this example, it's a very short
C C search.
C C
C CALL DLABFS ( HANDLE, DLADSC, FOUND )
C
C IF ( .NOT. FOUND ) THEN
C C
C C We arrive here only if the kernel
C C contains no segments. This is
C C unexpected, but we're prepared for it.
C C
C CALL SETMSG ( 'No segments found '
C . // 'in DSK file #.' )
C CALL ERRCH ( '#', DSK )
C CALL SIGERR ( 'SPICE(NODATA)' )
C
C END IF
C
C C
C C If we made it this far, DLADSC is the
C C DLA descriptor of the first segment.
C C
C C Find the number of plates in the model.
C C
C CALL DSKI02 ( HANDLE, DLADSC, KWNP, 1, 1, N, NP )
C
C C
C C For each plate, look up the desired data.
C C
C DO I = 1, NP
C C
C C For the Ith plate, find the associated
C C vertex IDs. We must take into account
C C the fact that each plate has three
C C vertices when we compute the start
C C index.
C C
C START = 3*(I-1)+1
C
C CALL DSKI02 ( HANDLE, DLADSC, KWPLAT, START,
C . 3, N, VRTIDS )
C
C DO J = 1, 3
C C
C C Fetch the vertex associated with
C C the Jth vertex ID. Again, each
C C vertex is a 3-vector. Note that
C C the vertices are double-precision
C C data, so we fetch them using
C C DSKD02.
C C
C START = 3*( VRTIDS(J) - 1 ) + 1
C
C CALL DSKD02 ( HANDLE, DLADSC, KWVERT, START,
C . 3, N, VRTCES(1,J) )
C END DO
C
C C
C C Display the vertices of the Ith plate:
C C
C WRITE (*,*) ' '
C WRITE (*,*) 'Plate number: ', I
C WRITE (*,FMT) ' Vertex 1: ', (VRTCES(J,1), J=1,3)
C WRITE (*,FMT) ' Vertex 2: ', (VRTCES(J,2), J=1,3)
C WRITE (*,FMT) ' Vertex 3: ', (VRTCES(J,3), J=1,3)
C
C END DO
C
C C
C C Close the kernel. This isn't necessary in a stand-
C C alone program, but it's good practice in subroutines
C C because it frees program and system resources.
C C
C CALL DASCLS ( HANDLE )
C
C END
C
C
C When this program was executed on a PC/Linux/gfortran/64bit
C platform, using a DSK file representing a regular icosahedron,
C the output was:
C
C
C Enter DSK name > solid.bds
C
C Plate number: 1
C Vertex 1: 0.000000000E+00 0.000000000E+00 0.117557000E+01
C Vertex 2: 0.105146000E+01 0.000000000E+00 0.525731000E+00
C Vertex 3: 0.324920000E+00 0.100000000E+01 0.525731000E+00
C
C Plate number: 2
C Vertex 1: 0.000000000E+00 0.000000000E+00 0.117557000E+01
C Vertex 2: 0.324920000E+00 0.100000000E+01 0.525731000E+00
C Vertex 3: -0.850651000E+00 0.618034000E+00 0.525731000E+00
C
C ...
C
C Plate number: 20
C Vertex 1: 0.850651000E+00 -0.618034000E+00 -0.525731000E+00
C Vertex 2: 0.000000000E+00 0.000000000E+00 -0.117557000E+01
C Vertex 3: 0.850651000E+00 0.618034000E+00 -0.525731000E+00
C
C
C$ Restrictions
C
C 1) This routine uses discovery check-in to boost
C execution speed. However, this routine is in
C violation of NAIF standards for use of discovery
C check-in: routines called from this routine may
C signal errors. If errors are signaled in called
C routines, this routine's name will be missing
C from the traceback message.
C
C$ Literature_References
C
C None.
C
C$ Author_and_Institution
C
C N.J. Bachman (JPL)
C
C$ Version
C
C- SPICELIB Version 1.0.0, 22-NOV-2016 (NJB)
C
C Added FAILED check after segment attribute fetch calls.
C Re-ordered code so that values are saved only after
C all error checks have passed. Simplified base address
C comparisons.
C
C 15-JAN-2016 (NJB)
C
C Updated header Examples and Particulars sections.
C
C DSKLIB Version 1.0.2, 11-JUL-2014 (NJB)
C
C Fixed a trivial header comment typo.
C
C DSKLIB Version 1.0.1, 13-MAY-2010 (NJB)
C
C Updated header.
C
C DSKLIB Version 1.0.0, 27-OCT-2006 (NJB)
C
C-&
C$ Index_Entries
C
C fetch integer data from a type 2 dsk segment
C
C-&
C
C SPICELIB functions
C
LOGICAL FAILED
C
C Local parameters
C
C
C IBFSIZ is the size of an integer buffer used to
C read parameters from the segment.
C
INTEGER IBFSIZ
PARAMETER ( IBFSIZ = 10 )
C
C Local variables
C
INTEGER B
INTEGER CGSCAL
INTEGER E
INTEGER IBASE
INTEGER IBUFF ( IBFSIZ )
INTEGER NCGR
INTEGER NP
INTEGER NV
INTEGER NVXTOT
INTEGER PRVBAS
INTEGER PRVHAN
INTEGER SIZE
INTEGER VOXNPL
INTEGER VOXNPT
INTEGER VTXNPL
LOGICAL FIRST
C
C Saved variables
C
SAVE CGSCAL
SAVE FIRST
SAVE NP
SAVE NV
SAVE NVXTOT
SAVE PRVBAS
SAVE PRVHAN
SAVE VOXNPL
SAVE VOXNPT
SAVE VTXNPL
C
C Initial values
C
DATA FIRST / .TRUE. /
C
C Use discovery check-in. This is done for efficiency; note
C however that this routine does not meet SPICE standards for
C discovery check-in eligibility.
C
IF ( FIRST ) THEN
C
C Make sure we treat the input handle as new on the first pass.
C Set PRVHAN to an invalid handle value.
C
PRVHAN = 0
C
C Set the previous segment base integer address to an invalid
C value as well.
C
PRVBAS = -1
FIRST = .FALSE.
END IF
IF ( ROOM .LE. 0 ) THEN
CALL CHKIN ( 'DSKI02' )
CALL SETMSG ( 'ROOM was #; must be positive.' )
CALL ERRINT ( '#', ROOM )
CALL SIGERR ( 'SPICE(VALUEOUTOFRANGE)' )
CALL CHKOUT ( 'DSKI02' )
RETURN
END IF
IBASE = DLADSC ( IBSIDX )
C
C Either a new file or new segment in the same file will require
C looking up the segment parameters. To determine whether the
C segment is new, we don't need to compare the entire DLA
C descriptor: just comparing the integer base address of the
C descriptor against the saved integer base address is sufficient.
C
C DSK type 2 segments always have a non-empty integer component, so
C each type 2 segment in a given file will have a distinct integer
C base address. Segments of other types might not contain integers,
C but they can't share an integer base address with a type 2
C segment.
C
IF ( ( HANDLE .NE. PRVHAN )
. .OR. ( IBASE .NE. PRVBAS ) ) THEN
C
C Treat the input file and segment as new.
C
C Read the integer parameters first. These are located at the
C beginning of the integer component of the segment.
C
CALL DASRDI ( HANDLE, IBASE+1, IBASE+IBFSIZ, IBUFF )
IF ( FAILED() ) THEN
RETURN
END IF
C
C Check the coarse voxel scale.
C
IF ( IBUFF(IXCGSC) .LT. 1 ) THEN
CALL CHKIN ( 'DSKI02' )
CALL SETMSG ( 'Coarse voxel grid scale is #; ' //
. 'this scale should be an ' //
. 'integer > 1' )
CALL ERRINT ( '#', CGSCAL )
CALL SIGERR ( 'SPICE(VALUEOUTOFRANGE)' )
CALL CHKOUT ( 'DSKI02' )
RETURN
END IF
C
C All checks have passed. We can safely store the segment
C parameters.
C
NV = IBUFF ( IXNV )
NP = IBUFF ( IXNP )
NVXTOT = IBUFF ( IXNVXT )
CGSCAL = IBUFF ( IXCGSC )
VTXNPL = IBUFF ( IXVTLS )
VOXNPT = IBUFF ( IXVXPS )
VOXNPL = IBUFF ( IXVXLS )
C
C Update the saved handle value.
C
PRVHAN = HANDLE
C
C Update the saved base integer address.
C
PRVBAS = IBASE
END IF
C
C Branch based on the item to be returned.
C
C Note that we haven't checked the validity of START; we'll do this
C after the IF block.
C
IF ( ITEM .EQ. KWNV ) THEN
C
C Return the number of vertices.
C
N = 1
VALUES(1) = NV
C
C As long as START is valid, we can return. Otherwise,
C let control pass to the error handling block near
C the end of this routine.
C
IF ( START .EQ. 1 ) THEN
RETURN
END IF
ELSE IF ( ITEM .EQ. KWNP ) THEN
C
C Return the number of plates.
C
N = 1
VALUES(1) = NP
IF ( START .EQ. 1 ) THEN
RETURN
END IF
ELSE IF ( ITEM .EQ. KWNVXT ) THEN
C
C Return the total number of voxels.
C
N = 1
VALUES(1) = NVXTOT
IF ( START .EQ. 1 ) THEN
RETURN
END IF
ELSE IF ( ITEM .EQ. KWVGRX ) THEN
C
C Return the voxel grid extents.
C
SIZE = 3
B = IBASE + IXVGRX + START - 1
ELSE IF ( ITEM .EQ. KWCGSC ) THEN
C
C Return the coarse voxel grid scale.
C
N = 1
VALUES(1) = CGSCAL
IF ( START .EQ. 1 ) THEN
RETURN
END IF
ELSE IF ( ITEM .EQ. KWVXPS ) THEN
C
C Return the voxel-plate pointer list size.
C
N = 1
VALUES(1) = VOXNPT
IF ( START .EQ. 1 ) THEN
RETURN
END IF
ELSE IF ( ITEM .EQ. KWVXLS ) THEN
C
C Return the voxel-plate list size.
C
N = 1
VALUES(1) = VOXNPL
IF ( START .EQ. 1 ) THEN
RETURN
END IF
ELSE IF ( ITEM .EQ. KWVTLS ) THEN
C
C Return the vertex-plate list size.
C
N = 1
VALUES(1) = VTXNPL
IF ( START .EQ. 1 ) THEN
RETURN
END IF
ELSE IF ( ITEM .EQ. KWPLAT ) THEN
C
C Return plate data. There are 3*NP values in all. First
C locate the data.
C
SIZE = 3*NP
B = ( IBASE + IXPLAT ) + START - 1
ELSE IF ( ITEM .EQ. KWVXPT ) THEN
C
C Return voxel pointer data. There are VOXNPT values in all.
C First locate the data.
C
SIZE = VOXNPT
B = ( IBASE + IXPLAT + 3*NP ) + START - 1
ELSE IF ( ITEM .EQ. KWVXPL ) THEN
C
C Return voxel-plate list data. There are VOXNPL values in all.
C First locate the data.
C
SIZE = VOXNPL
B = ( IBASE + IXPLAT + 3*NP + VOXNPT ) + START - 1
ELSE IF ( ITEM .EQ. KWVTPT ) THEN
C
C Return vertex-plate pointer data. There are NV values in all.
C First locate the data.
C
SIZE = NV
B = ( IBASE + IXPLAT + 3*NP + VOXNPT + VOXNPL )
. + START - 1
ELSE IF ( ITEM .EQ. KWVTPL ) THEN
C
C Return vertex-plate list data. There are VTXNPL values in
C all. First locate the data.
C
SIZE = VTXNPL
B = ( IBASE + IXPLAT + 3*NP + VOXNPT + VOXNPL + NV )
. + START - 1
ELSE IF ( ITEM .EQ. KWCGPT ) THEN
C
C Compute the coarse grid size.
C
NCGR = NVXTOT / (CGSCAL**3)
C
C Return the coarse voxel grid occupancy pointers. There are
C
C NCGR
C
C values in all. First locate the data.
C
SIZE = NCGR
B = ( IBASE + IXPLAT + 3*NP + VOXNPT
. + VOXNPL + NV + VTXNPL )
. + START - 1
ELSE
CALL CHKIN ( 'DSKI02' )
CALL SETMSG ( 'Keyword parameter # was not recognized.' )
CALL ERRINT ( '#', ITEM )
CALL SIGERR ( 'SPICE(NOTSUPPORTED)' )
CALL CHKOUT ( 'DSKI02' )
RETURN
END IF
C
C The valid range for START is 1:SIZE.
C
IF ( ( START .LT. 1 ) .OR. ( START .GT. SIZE ) ) THEN
CALL CHKIN ( 'DSKI02' )
CALL SETMSG ( 'START must be in the range defined ' //
. 'by the size of the data associated ' //
. 'with the keyword parameter #, ' //
. 'namely 1:#. Actual value of START ' //
. 'was #.' )
CALL ERRINT ( '#', ITEM )
CALL ERRINT ( '#', SIZE )
CALL ERRINT ( '#', START )
CALL SIGERR ( 'SPICE(INDEXOUTOFRANGE)' )
CALL CHKOUT ( 'DSKI02' )
RETURN
END IF
C
C Read the requested data. We already have the start address B.
C
N = MIN ( ROOM, SIZE - START + 1 )
E = B + N - 1
CALL DASRDI ( HANDLE, B, E, VALUES )
RETURN
END
|
# --------------------------------------------------------------------------
# ACE.jl and SHIPs.jl: Julia implementation of the Atomic Cluster Expansion
# Copyright (c) 2019 Christoph Ortner <[email protected]>
# Licensed under ASL - see ASL.md for terms and conditions.
# --------------------------------------------------------------------------
using ACE, JuLIP, BenchmarkTools
#---
basis = ACE.Utils.rpi_basis(; species=:Si, N = 5, maxdeg = 14)
@show length(basis)
V = ACE.Random.randcombine(basis)
#---
at = bulk(:Si, cubic=true) * 5
nlist = neighbourlist(at, cutoff(V))
tmp = JuLIP.alloc_temp(V, maxneigs(nlist))
tmp_d = JuLIP.alloc_temp_d(V, maxneigs(nlist))
F = zeros(JVecF, length(at))
@code_warntype JuLIP.energy!(tmp, V, at)
@code_warntype JuLIP.forces!(F, tmp_d, V, at)
@btime JuLIP.forces!($F, $tmp_d, $V, $at)
@btime JuLIP.forces($V, $at)
|
# -*- coding: utf-8 -*-
"""
@date: 2021/7/28 δΈε5:51
@file: diver_branch_block.py
@author: zj
@description:
refer to [DingXiaoH/DiverseBranchBlock](https://github.com/DingXiaoH/DiverseBranchBlock)
"""
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from .. import init_helper
def conv_bn(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1,
padding_mode='zeros'):
conv_layer = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size,
stride=(stride, stride), padding=padding, dilation=(dilation, dilation), groups=groups,
bias=False, padding_mode=padding_mode)
bn_layer = nn.BatchNorm2d(num_features=out_channels, affine=True)
se = nn.Sequential()
se.add_module('conv', conv_layer)
se.add_module('bn', bn_layer)
return se
class IdentityBasedConv1x1(nn.Conv2d):
def __init__(self, channels, groups=1):
super(IdentityBasedConv1x1, self).__init__(in_channels=channels, out_channels=channels,
kernel_size=(1, 1), stride=(1, 1),
padding=0, groups=groups, bias=False)
assert channels % groups == 0
input_dim = channels // groups
id_value = np.zeros((channels, input_dim, 1, 1))
for i in range(channels):
id_value[i, i % input_dim, 0, 0] = 1
self.id_tensor = torch.from_numpy(id_value).type_as(self.weight)
nn.init.zeros_(self.weight)
def forward(self, input):
kernel = self.weight + self.id_tensor.to(self.weight.device)
result = F.conv2d(input, kernel, None, stride=1, padding=0, dilation=self.dilation, groups=self.groups)
return result
def get_actual_kernel(self):
return self.weight + self.id_tensor.to(self.weight.device)
class BNAndPadLayer(nn.Module):
def __init__(self,
pad_pixels,
num_features,
eps=1e-5,
momentum=0.1,
affine=True,
track_running_stats=True):
super(BNAndPadLayer, self).__init__()
self.bn = nn.BatchNorm2d(num_features, eps, momentum, affine, track_running_stats)
self.pad_pixels = pad_pixels
def forward(self, input):
output = self.bn(input)
if self.pad_pixels > 0:
if self.bn.affine:
pad_values = self.bn.bias.detach() - self.bn.running_mean * self.bn.weight.detach() / torch.sqrt(
self.bn.running_var + self.bn.eps)
else:
pad_values = - self.bn.running_mean / torch.sqrt(self.bn.running_var + self.bn.eps)
output = F.pad(output, [self.pad_pixels] * 4)
pad_values = pad_values.view(1, -1, 1, 1)
output[:, :, 0:self.pad_pixels, :] = pad_values
output[:, :, -self.pad_pixels:, :] = pad_values
output[:, :, :, 0:self.pad_pixels] = pad_values
output[:, :, :, -self.pad_pixels:] = pad_values
return output
@property
def weight(self):
return self.bn.weight
@property
def bias(self):
return self.bn.bias
@property
def running_mean(self):
return self.bn.running_mean
@property
def running_var(self):
return self.bn.running_var
@property
def eps(self):
return self.bn.eps
class DiverseBranchBlock(nn.Module):
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
padding=0,
dilation=1,
groups=1,
internal_channels_1x1_3x3=None,
single_init=False):
super(DiverseBranchBlock, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.kernel_size = kernel_size
self.stride = stride
self.padding = padding
self.dilation = dilation
self.groups = groups
assert padding == kernel_size // 2
self.dbb_origin = conv_bn(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size,
stride=stride, padding=padding, dilation=dilation, groups=groups)
self.dbb_avg = nn.Sequential()
if groups < out_channels:
self.dbb_avg.add_module('conv', nn.Conv2d(in_channels=in_channels, out_channels=out_channels,
kernel_size=(1, 1), stride=(1, 1),
padding=0, groups=groups, bias=False))
self.dbb_avg.add_module('bn', BNAndPadLayer(pad_pixels=padding, num_features=out_channels))
self.dbb_avg.add_module('avg', nn.AvgPool2d(kernel_size=kernel_size, stride=stride, padding=0))
# For ordinary convolution, an additional 1x1conv+BN branch is added
self.dbb_1x1 = conv_bn(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=stride,
padding=0, groups=groups)
else:
# For depthwise convolution, the pre 1x1conv+BN are cancelled
self.dbb_avg.add_module('avg', nn.AvgPool2d(kernel_size=kernel_size, stride=stride, padding=padding))
self.dbb_avg.add_module('avgbn', nn.BatchNorm2d(out_channels))
if internal_channels_1x1_3x3 is None:
# For mobilenet, it is better to have 2X internal channels
internal_channels_1x1_3x3 = in_channels if groups < out_channels else 2 * in_channels
self.dbb_1x1_kxk = nn.Sequential()
if internal_channels_1x1_3x3 == in_channels:
self.dbb_1x1_kxk.add_module('idconv1', IdentityBasedConv1x1(channels=in_channels, groups=groups))
else:
self.dbb_1x1_kxk.add_module('conv1', nn.Conv2d(in_channels=in_channels,
out_channels=internal_channels_1x1_3x3,
kernel_size=(1, 1), stride=(1, 1), padding=0, groups=groups,
bias=False))
self.dbb_1x1_kxk.add_module('bn1', BNAndPadLayer(pad_pixels=padding, num_features=internal_channels_1x1_3x3,
affine=True))
self.dbb_1x1_kxk.add_module('conv2',
nn.Conv2d(in_channels=internal_channels_1x1_3x3, out_channels=out_channels,
kernel_size=kernel_size, stride=(stride, stride), padding=0,
groups=groups, bias=False))
self.dbb_1x1_kxk.add_module('bn2', nn.BatchNorm2d(out_channels))
self.init_weights()
# The experiments reported in the paper used the default initialization of bn.weight (all as 1). But changing the initialization may be useful in some cases.
if single_init:
# Initialize the bn.weight of dbb_origin as 1 and others as 0. This is not the default setting.
self.single_init()
def forward(self, inputs):
out = self.dbb_origin(inputs)
if hasattr(self, 'dbb_1x1'):
out += self.dbb_1x1(inputs)
out += self.dbb_avg(inputs)
out += self.dbb_1x1_kxk(inputs)
return out
def init_weights(self):
if hasattr(self, "dbb_origin"):
init_helper.init_weights(self.dbb_origin)
if hasattr(self, "dbb_1x1"):
init_helper.init_weights(self.dbb_1x1)
if hasattr(self, "dbb_avg"):
init_helper.init_weights(self.dbb_avg)
if hasattr(self, "dbb_1x1_kxk"):
init_helper.init_weights(self.dbb_1x1_kxk)
def init_gamma(self, gamma_value):
if hasattr(self, "dbb_origin"):
torch.nn.init.constant_(self.dbb_origin.bn.weight, gamma_value)
if hasattr(self, "dbb_1x1"):
torch.nn.init.constant_(self.dbb_1x1.bn.weight, gamma_value)
if hasattr(self, "dbb_avg"):
torch.nn.init.constant_(self.dbb_avg.avgbn.weight, gamma_value)
if hasattr(self, "dbb_1x1_kxk"):
torch.nn.init.constant_(self.dbb_1x1_kxk.bn2.weight, gamma_value)
def single_init(self):
self.init_gamma(0.0)
if hasattr(self, "dbb_origin"):
torch.nn.init.constant_(self.dbb_origin.bn.weight, 1.0)
|
function anonTextureS = defineAnonTexture()
%
% function anonTextureS = defineAnonCerroptions()
%
% Defines the anonymous "texture" data structure. The fields containing PHI have
% been left out by default. In order to leave out additional fields, remove
% them from the list below.
%
% The following three operations are allowed per field of the input data structure:
% 1. Keep the value as is: listed as 'keep' in the list below.
% 2. Allow only the specific values: permitted values listed within a cell array.
% If no match is found, a default anonymous string will be inserted.
% 3. Insert dummy date: listed as 'date' in the list below. Date will be
% replaced by a dummy value of 11/11/1111.
%
% APA, 1/11/2018
anonTextureS = struct( ...
'category', 'keep', ...
'description', 'keep', ...
'patchSize', 'keep', ...
'patchUnit', 'keep', ...
'paramS', 'keep', ...
'assocScanUID', 'keep', ...
'assocStructUID', 'keep', ...
'textureUID', 'keep' ...
);
|
// ---------------------------------------------------------------------------|
// Test Harness includes
// ---------------------------------------------------------------------------|
#include "test/support/misc-util/ptree-utils.h"
// ---------------------------------------------------------------------------|
// Standard includes
// ---------------------------------------------------------------------------|
#include <sstream>
#include <iostream>
// ---------------------------------------------------------------------------|
// Boost includes
// ---------------------------------------------------------------------------|
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>
// ---------------------------------------------------------------------------|
// Filewide namespace usage
// ---------------------------------------------------------------------------|
using namespace std;
using boost::property_tree::ptree;
// ---------------------------------------------------------------------------|
namespace YumaTest
{
// ---------------------------------------------------------------------------|
namespace PTreeUtils
{
// ---------------------------------------------------------------------------|
void Display( const ptree& pt)
{
BOOST_FOREACH( const ptree::value_type& v, pt )
{
if ( v.first == "xpo" )
{
cout << "Node is xpo\n";
}
cout << v.first << " : " << v.second.get_value<string>() << "\n";
Display( v.second );
}
}
// ---------------------------------------------------------------------------|
ptree ParseXMlString( const string& xmlString )
{
using namespace boost::property_tree::xml_parser;
// Create empty property tree object
ptree pt;
istringstream ss( xmlString );
read_xml( ss, pt, trim_whitespace );
return pt;
}
}} // namespace YumaTest::PTreeUtils
|
#' Identify intervals within a specified distance.
#'
#' @param x [ivl_df]
#' @param y [ivl_df]
#' @param ... params for bed_slop and bed_intersect
#' @inheritParams bed_slop
#' @inheritParams bed_intersect
#'
#' @template groups
#'
#' @family multiple set operations
#' @examples
#' x <- tibble::tribble(
#' ~chrom, ~start, ~end,
#' 'chr1', 25, 50,
#' 'chr1', 100, 125
#' )
#'
#' y <- tibble::tribble(
#' ~chrom, ~start, ~end,
#' 'chr1', 60, 75
#' )
#'
#' genome <- tibble::tribble(
#' ~chrom, ~size,
#' 'chr1', 125
#' )
#'
#' bed_glyph(bed_window(x, y, genome, both = 15))
#'
#' x <- tibble::tribble(
#' ~chrom, ~start, ~end,
#' "chr1", 10, 100,
#' "chr2", 200, 400,
#' "chr2", 300, 500,
#' "chr2", 800, 900
#' )
#'
#' y <- tibble::tribble(
#' ~chrom, ~start, ~end,
#' "chr1", 150, 400,
#' "chr2", 230, 430,
#' "chr2", 350, 430
#' )
#'
#' genome <- tibble::tribble(
#' ~chrom, ~size,
#' "chr1", 500,
#' "chr2", 1000
#' )
#'
#' bed_window(x, y, genome, both = 100)
#'
#' @seealso \url{https://bedtools.readthedocs.io/en/latest/content/tools/window.html}
#'
#' @export
bed_window <- function(x, y, genome, ...) {
x <- check_interval(x)
y <- check_interval(y)
genome <- check_genome(genome)
x <- mutate(x, .start = start, .end = end)
# capture command line args
cmd_args <- list(...)
# get arguments for bed_slop and bed_intersect
slop_arg_names <- names(formals(bed_slop))
intersect_arg_names <- names(formals(bed_intersect))
# parse supplied args into those for bed_slop or bed_intersect
slop_args <- cmd_args[names(cmd_args) %in% slop_arg_names]
intersect_args <- cmd_args[names(cmd_args) %in% intersect_arg_names]
# pass new list of args to bed_slop
slop_x <- do.call(
bed_slop,
c(list("x" = x, "genome" = genome), slop_args)
)
# pass new list of args to bed_intersect
res <- do.call(
bed_intersect,
c(list("x" = slop_x, "y" = y), intersect_args)
)
res <- mutate(res, start.x = .start.x, end.x = .end.x)
res <- ungroup(res)
res <- select(res, -.start.x, -.end.x)
res
}
|
= = = Academic reviews of books by Finkelstein = = =
|
[STATEMENT]
lemma (in carrier) core_subset:
"core a \<subseteq> a"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. core a \<subseteq> a
[PROOF STEP]
by (auto simp: cor_def) |
# Copyright (c) 2018-2021, Carnegie Mellon University
# See LICENSE for details
ImportAll(paradigms.scratchpad);
doNormalWHT := function(arg)
local N, t, rt, srt, code, a;
N := When(Length(arg) >=1, arg[1], 2);
t := WHT(N);
rt := RandomRuleTree(t, SpiralDefaults);
srt := SumsRuleTree(rt, SpiralDefaults);
code := CodeSums(srt, SpiralDefaults);
a := CMatrix(code, SpiralDefaults);
return a;
end;
doScratchWHT := function(arg)
local N, ls, opts, t, rt, srt, code, b;
N := When(Length(arg) >=1, arg[1], 2);
ls := When(Length(arg) >=2, 2^arg[2],2);
opts := ScratchX86CMContext.getOpts(ls,1,1,N);
t := WHT(opts.size).withTags(opts.tags);
rt := RandomRuleTree(t, opts);
srt := SumsRuleTree(rt, opts);
code := CodeSums(srt, opts);
b := CMatrix(code, opts);
return b;
end;
doWHT := function(arg)
local N, N1, i, j, a, b;
SpiralDefaults.includes := ["\"scratchc.h\""];
SpiralDefaults.profile.makeopts.CFLAGS := "-O2 -Wall -fomit-frame-pointer -msse4.1 -std=gnu99 -static";
N := When(Length(arg) >= 1, arg[1], 2);
for i in [2..N] do
a := doNormalWHT(i);
N1 := i - 1;
for j in [1..N1] do
b := doScratchWHT(i,j);
PrintLine("Size of WHT:", 2^i);
PrintLine("Scratch buffer size:", 2^j);
PrintLine(a=b);
PrintLine("------------------------------------------");
od;
od;
end;
|
lemma nonzero_of_real_inverse: "x \<noteq> 0 \<Longrightarrow> of_real (inverse x) = inverse (of_real x :: 'a::real_div_algebra)" |
/-
Copyright (c) 2014 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Leonardo de Moura, Jeremy Avigad
-/
/-!
# booleans
This file proves various trivial lemmas about booleans and their
relation to decidable propositions.
## Notations
This file introduces the notation `!b` for `bnot b`, the boolean "not".
## Tags
bool, boolean, De Morgan
-/
prefix `!`:90 := bnot
namespace bool
-- TODO: duplicate of a lemma in core
theorem coe_sort_tt : coe_sort.{1 1} tt = true := coe_sort_tt
-- TODO: duplicate of a lemma in core
theorem coe_sort_ff : coe_sort.{1 1} ff = false := coe_sort_ff
-- TODO: duplicate of a lemma in core
theorem to_bool_true {h} : @to_bool true h = tt :=
to_bool_true_eq_tt h
-- TODO: duplicate of a lemma in core
theorem to_bool_false {h} : @to_bool false h = ff :=
to_bool_false_eq_ff h
@[simp] theorem to_bool_coe (b:bool) {h} : @to_bool b h = b :=
(show _ = to_bool b, by congr).trans (by cases b; refl)
theorem coe_to_bool (p : Prop) [decidable p] : to_bool p β p := to_bool_iff _
@[simp] lemma of_to_bool_iff {p : Prop} [decidable p] : to_bool p β p :=
β¨of_to_bool_true, _root_.to_bool_trueβ©
@[simp] lemma tt_eq_to_bool_iff {p : Prop} [decidable p] : tt = to_bool p β p :=
eq_comm.trans of_to_bool_iff
@[simp] lemma ff_eq_to_bool_iff {p : Prop} [decidable p] : ff = to_bool p β Β¬ p :=
eq_comm.trans (to_bool_ff_iff _)
@[simp] theorem to_bool_not (p : Prop) [decidable p] : to_bool (Β¬ p) = bnot (to_bool p) :=
by by_cases p; simp *
@[simp] theorem to_bool_and (p q : Prop) [decidable p] [decidable q] :
to_bool (p β§ q) = p && q :=
by by_cases p; by_cases q; simp *
@[simp] theorem to_bool_or (p q : Prop) [decidable p] [decidable q] :
to_bool (p β¨ q) = p || q :=
by by_cases p; by_cases q; simp *
@[simp] theorem to_bool_eq {p q : Prop} [decidable p] [decidable q] :
to_bool p = to_bool q β (p β q) :=
β¨Ξ» h, (coe_to_bool p).symm.trans $ by simp [h], to_bool_congrβ©
lemma not_ff : Β¬ ff := ff_ne_tt
@[simp] theorem default_bool : default = ff := rfl
theorem dichotomy (b : bool) : b = ff β¨ b = tt :=
by cases b; simp
@[simp] theorem forall_bool {p : bool β Prop} : (β b, p b) β p ff β§ p tt :=
β¨Ξ» h, by simp [h], Ξ» β¨hβ, hββ© b, by cases b; assumptionβ©
@[simp] theorem exists_bool {p : bool β Prop} : (β b, p b) β p ff β¨ p tt :=
β¨Ξ» β¨b, hβ©, by cases b; [exact or.inl h, exact or.inr h],
Ξ» h, by cases h; exact β¨_, hβ©β©
/-- If `p b` is decidable for all `b : bool`, then `β b, p b` is decidable -/
instance decidable_forall_bool {p : bool β Prop} [β b, decidable (p b)] : decidable (β b, p b) :=
decidable_of_decidable_of_iff and.decidable forall_bool.symm
/-- If `p b` is decidable for all `b : bool`, then `β b, p b` is decidable -/
instance decidable_exists_bool {p : bool β Prop} [β b, decidable (p b)] : decidable (β b, p b) :=
decidable_of_decidable_of_iff or.decidable exists_bool.symm
@[simp] theorem cond_ff {Ξ±} (t e : Ξ±) : cond ff t e = e := rfl
@[simp] theorem cond_tt {Ξ±} (t e : Ξ±) : cond tt t e = t := rfl
@[simp] theorem cond_to_bool {Ξ±} (p : Prop) [decidable p] (t e : Ξ±) :
cond (to_bool p) t e = if p then t else e :=
by by_cases p; simp *
@[simp] theorem cond_bnot {Ξ±} (b : bool) (t e : Ξ±) : cond (!b) t e = cond b e t :=
by cases b; refl
theorem coe_bool_iff : β {a b : bool}, (a β b) β a = b := dec_trivial
theorem eq_tt_of_ne_ff : β {a : bool}, a β ff β a = tt := dec_trivial
theorem eq_ff_of_ne_tt : β {a : bool}, a β tt β a = ff := dec_trivial
theorem bor_comm : β a b, a || b = b || a := dec_trivial
@[simp] theorem bor_assoc : β a b c, (a || b) || c = a || (b || c) := dec_trivial
theorem bor_left_comm : β a b c, a || (b || c) = b || (a || c) := dec_trivial
theorem bor_inl {a b : bool} (H : a) : a || b :=
by simp [H]
theorem bor_inr {a b : bool} (H : b) : a || b :=
by simp [H]
theorem band_comm : β a b, a && b = b && a := dec_trivial
@[simp] theorem band_assoc : β a b c, (a && b) && c = a && (b && c) := dec_trivial
theorem band_left_comm : β a b c, a && (b && c) = b && (a && c) := dec_trivial
theorem band_elim_left : β {a b : bool}, a && b β a := dec_trivial
theorem band_intro : β {a b : bool}, a β b β a && b := dec_trivial
theorem band_elim_right : β {a b : bool}, a && b β b := dec_trivial
lemma band_bor_distrib_left (a b c : bool) : a && (b || c) = a && b || a && c := by cases a; simp
lemma band_bor_distrib_right (a b c : bool) : (a || b) && c = a && c || b && c := by cases c; simp
lemma bor_band_distrib_left (a b c : bool) : a || b && c = (a || b) && (a || c) := by cases a; simp
lemma bor_band_distrib_right (a b c : bool) : a && b || c = (a || c) && (b || c) := by cases c; simp
@[simp] theorem bnot_false : bnot ff = tt := rfl
@[simp] theorem bnot_true : bnot tt = ff := rfl
@[simp] lemma not_eq_bnot : β {a b : bool}, Β¬a = !b β a = b := dec_trivial
@[simp] lemma bnot_not_eq : β {a b : bool}, Β¬!a = b β a = b := dec_trivial
lemma ne_bnot {a b : bool} : a β !b β a = b := not_eq_bnot
lemma bnot_ne {a b : bool} : !a β b β a = b := bnot_not_eq
@[simp] theorem bnot_iff_not : β {b : bool}, !b β Β¬b := dec_trivial
theorem eq_tt_of_bnot_eq_ff : β {a : bool}, bnot a = ff β a = tt := dec_trivial
theorem eq_ff_of_bnot_eq_tt : β {a : bool}, bnot a = tt β a = ff := dec_trivial
@[simp] lemma band_bnot_self : β x, x && !x = ff := dec_trivial
@[simp] lemma bnot_band_self : β x, !x && x = ff := dec_trivial
@[simp] lemma bor_bnot_self : β x, x || !x = tt := dec_trivial
@[simp] lemma bnot_bor_self : β x, !x || x = tt := dec_trivial
theorem bxor_comm : β a b, bxor a b = bxor b a := dec_trivial
@[simp] theorem bxor_assoc : β a b c, bxor (bxor a b) c = bxor a (bxor b c) := dec_trivial
theorem bxor_left_comm : β a b c, bxor a (bxor b c) = bxor b (bxor a c) := dec_trivial
@[simp] theorem bxor_bnot_left : β a, bxor (!a) a = tt := dec_trivial
@[simp] theorem bxor_bnot_right : β a, bxor a (!a) = tt := dec_trivial
@[simp] theorem bxor_bnot_bnot : β a b, bxor (!a) (!b) = bxor a b := dec_trivial
@[simp] theorem bxor_ff_left : β a, bxor ff a = a := dec_trivial
@[simp] theorem bxor_ff_right : β a, bxor a ff = a := dec_trivial
lemma band_bxor_distrib_left (a b c : bool) : a && (bxor b c) = bxor (a && b) (a && c) :=
by cases a; simp
lemma band_bxor_distrib_right (a b c : bool) : (bxor a b) && c = bxor (a && c) (b && c) :=
by cases c; simp
lemma bxor_iff_ne : β {x y : bool}, bxor x y = tt β x β y := dec_trivial
/-! ### De Morgan's laws for booleans-/
@[simp] lemma bnot_band : β (a b : bool), !(a && b) = !a || !b := dec_trivial
@[simp] lemma bnot_bor : β (a b : bool), !(a || b) = !a && !b := dec_trivial
lemma bnot_inj : β {a b : bool}, !a = !b β a = b := dec_trivial
instance : linear_order bool :=
{ le := Ξ» a b, a = ff β¨ b = tt,
le_refl := dec_trivial,
le_trans := dec_trivial,
le_antisymm := dec_trivial,
le_total := dec_trivial,
decidable_le := infer_instance,
decidable_eq := infer_instance,
max := bor,
max_def := by { funext x y, revert x y, exact dec_trivial },
min := band,
min_def := by { funext x y, revert x y, exact dec_trivial } }
@[simp] lemma ff_le {x : bool} : ff β€ x := or.intro_left _ rfl
@[simp] lemma le_tt {x : bool} : x β€ tt := or.intro_right _ rfl
lemma lt_iff : β {x y : bool}, x < y β x = ff β§ y = tt := dec_trivial
@[simp] lemma ff_lt_tt : ff < tt := lt_iff.2 β¨rfl, rflβ©
lemma le_iff_imp : β {x y : bool}, x β€ y β (x β y) := dec_trivial
lemma band_le_left : β x y : bool, x && y β€ x := dec_trivial
lemma band_le_right : β x y : bool, x && y β€ y := dec_trivial
lemma le_band : β {x y z : bool}, x β€ y β x β€ z β x β€ y && z := dec_trivial
lemma left_le_bor : β x y : bool, x β€ x || y := dec_trivial
lemma right_le_bor : β x y : bool, y β€ x || y := dec_trivial
lemma bor_le : β {x y z}, x β€ z β y β€ z β x || y β€ z := dec_trivial
/-- convert a `bool` to a `β`, `false -> 0`, `true -> 1` -/
def to_nat (b : bool) : β :=
cond b 1 0
/-- convert a `β` to a `bool`, `0 -> false`, everything else -> `true` -/
def of_nat (n : β) : bool :=
to_bool (n β 0)
lemma of_nat_le_of_nat {n m : β} (h : n β€ m) : of_nat n β€ of_nat m :=
begin
simp [of_nat];
cases nat.decidable_eq n 0;
cases nat.decidable_eq m 0;
simp only [to_bool],
{ subst m, have h := le_antisymm h (nat.zero_le _),
contradiction },
{ left, refl }
end
lemma to_nat_le_to_nat {bβ bβ : bool} (h : bβ β€ bβ) : to_nat bβ β€ to_nat bβ :=
by cases h; subst h; [cases bβ, cases bβ]; simp [to_nat,nat.zero_le]
lemma of_nat_to_nat (b : bool) : of_nat (to_nat b) = b :=
by cases b; simp only [of_nat,to_nat]; exact dec_trivial
@[simp] lemma injective_iff {Ξ± : Sort*} {f : bool β Ξ±} : function.injective f β f ff β f tt :=
β¨Ξ» Hinj Heq, ff_ne_tt (Hinj Heq),
Ξ» H x y hxy, by { cases x; cases y, exacts [rfl, (H hxy).elim, (H hxy.symm).elim, rfl] }β©
/-- **Kaminski's Equation** -/
theorem apply_apply_apply (f : bool β bool) (x : bool) : f (f (f x)) = f x :=
by cases x; cases hβ : f tt; cases hβ : f ff; simp only [hβ, hβ]
end bool
|
## by peter m crosta: pmcrosta at gmail
### Functions for oaxac decompositions in R given sample means and regression coefficients as inputs.
setwd('~/CSVs')
# read in means file
meansraw <- read.csv('means.csv', header=T, stringsAsFactors=F)
# read in coeffs file
coeffsraw <- read.csv('coeffs.csv', header=T, stringsAsFactors=F)
meansraw <- meansraw[meansraw$X!="",]
coeffsraw <- coeffsraw[coeffsraw$X!="",]
coefnames <- coeffsraw$X
sumnames <- meansraw$X
coefcol <- colnames(coeffsraw)
sumcol <- colnames(meansraw)
oaxaca <- function(mods) UseMethod("oaxaca")
oaxaca.default <- function(mods) {
## Input is a charactervector. Likely taken from a list
mod1 <- mods[1]
mod2 <- mods[2]
### get model coefficients
m1 <- as.numeric(coeffsraw[, which(mod1==coefcol)])
m2 <- as.numeric(coeffsraw[, which(mod2==coefcol)])
names(m1)<-coefnames
names(m2)<-coefnames
m1 <- na.omit(m1)
m2 <- na.omit(m2)
## get means
s1 <- as.numeric(meansraw[, which(mod1==sumcol)])
s2 <- as.numeric(meansraw[, which(mod2==sumcol)])
names(s1)<-sumnames
names(s2)<-sumnames
s1 <- na.omit(s1)
s2 <- na.omit(s2)
if (substr(mod1,1,1)=="r") depvar <- "readdep" else if (substr(mod1,1,1)=="m") depvar <- "mathdep"
k <- NROW(m1)
k1 <- NROW(m2)
if (k != k1) stop("models are not the same size")
W <- list("W = 1 (Oaxaca, 1973)" = diag(1, k),
"W = 0 (Blinder, 1973)" = diag(0, k),
"W = 0.5 (Reimers 1983)" = diag(0.5, k))
mnames <- names(m1)[-which(names(m1)=="Constant")]
X1 <- c(s1[mnames], 1)
X2 <- c(s2[mnames], 1)
Q <- sapply(W, function(w) crossprod(X1 - X2, w %*% m1 + (diag(1, k) - w) %*% m2))
U <- sapply(W, function(w) (crossprod(X1, diag(1, k) - w) + crossprod(X2, w)) %*% (m1 - m2))
attcoeff <- c("_Iattdec_2", "_Iattdec_3", "_Iattdec_4", "_Iattdec_5", "_Iattdec_6", "_Iattdec_7", "_Iattdec_8", "_Iattdec_9", "_Iattdec_10")
#Qa <- sapply(W, function(w) crossprod(X1['lnattend'] - X2['lnattend'], w[1] %*% m1['lnattend'] + (diag(1, 1) - w[1]) %*% m2['lnattend']))
#Ua <- sapply(W, function(w) (crossprod(X1['lnattend'], diag(1, 1) - w[1]) + crossprod(X2['lnattend'], w[1])) %*% (m1['lnattend'] - m2['lnattend']))
Qa <- Ua <- 0
for (ii in attcoeff) {
Qa <- Qa + sapply(W, function(w) crossprod(X1[ii] - X2[ii], w[1] %*% m1[ii] + (diag(1, 1) - w[1]) %*% m2[ii]))
Ua <- Ua + sapply(W, function(w) (crossprod(X1[ii], diag(1, 1) - w[1]) + crossprod(X2[ii], w[1])) %*% (m1[ii] - m2[ii]))
}
KK<-length(X1)
Qdetail <- sapply(W, function(w) sapply(1:KK, function(jj) crossprod(X1[jj] - X2[jj], w[1] %*% m1[jj] + (diag(1, 1) - w[1]) %*% m2[jj])))
Udetail <- sapply(W, function(w) sapply(1:KK, function(jj) (crossprod(X1[jj], diag(1, 1) - w[1]) + crossprod(X2[jj], w[1])) %*% (m1[jj] - m2[jj])))
rownames(Qdetail) <- rownames(Udetail) <- c(mnames, "Constant")
# Var-covar matrices
setwd('~/outregs')
VB1 <- as.matrix(read.table(paste(mod1, 'mat.txt', sep='')))
VB2 <- as.matrix(read.table(paste(mod2, 'mat.txt', sep='')))
VX1 <- as.matrix(read.table(paste(mod1, 'cor.txt', sep='')))
VX2 <- as.matrix(read.table(paste(mod2, 'cor.txt', sep='')))
dep1 <- s1[depvar]
dep2 <- s2[depvar]
Ddep <- dep1-dep2
ans <- list(R = Ddep,
VR = crossprod(X1, VB1) %*% X1 + crossprod(m1, VX1) %*% m1 + sum(diag(VX1 %*% VB1)) +
crossprod(X2, VB2) %*% X2 + crossprod(m2, VX2) %*% m2 + sum(diag(VX2 %*% VB2)))
VQ <- sapply(W, function(w)
sum(diag((VX1 + VX2) %*% (w %*% tcrossprod(VB1, w) + (diag(1, k) - w) %*% tcrossprod(VB2, diag(1, k) - w)))) +
crossprod(X1 - X2, w %*% tcrossprod(VB1, w) + (diag(1, k) - w) %*% tcrossprod(VB2, diag(1, k) - w)) %*% (X1 - X2) +
crossprod(w %*% m1 + (diag(1, k) - w) %*% m2, VX1 + VX2) %*% (w %*% m1 + (diag(1, k) - w) %*% m2))
VU <- sapply(W, function(w)
sum(diag((crossprod(diag(1, k) - w, VX1) %*% (diag(1, k) - w) + crossprod(w, VX2) %*% w) %*% (VB1 + VB2))) +
crossprod(crossprod(diag(1, k) - w, X1) + crossprod(w, X2), VB1 + VB2) %*% (crossprod(diag(1, k) - w, X1) + crossprod(w, X2))+
crossprod(m1 - m2, crossprod(diag(1, k) - w, VX1) %*% (diag(1, k) - w) + crossprod(w, VX2) %*% w) %*% (m1 - m2))
ans$Q <- Q
ans$U <- U
ans$VQ <- VQ
ans$VU <- VU
ans$W <- W
ans$Qa <- Qa
ans$Ua <- Ua
ans$call <- match.call()
ans$mod1 <- mod1
ans$mod2 <- mod2
ans$Qdetail <- Qdetail
ans$Udetail <- Udetail
class(ans) <- "oaxaca"
ans
}
print.oaxaca <- function(x) {
se <- sqrt(x$VQ)
zval <- x$Q / se
decomp <- cbind(Explained = x$Q, StdErr = se, "z-value" = zval, "Pr(>|z|)" = 2*pnorm(-abs(zval)))
cat("\nBlinder-Oaxaca decomposition\n\nCall:\n")
print(x$call)
cat(x$mod1, ' ', x$mod2, "\n")
decomp <- matrix(nrow = 1, ncol = 4)
decomp[1, c(1, 2)] <- c(x$R, sqrt(x$VR))
decomp[1, 3] <- c(decomp[, 1] / decomp[, 2])
decomp[1, 4] <- c(2 * pnorm(-abs(decomp[, 3])))
colnames(decomp) <- c("Difference", "StdErr", "z-value", "Pr(>|z|)")
rownames(decomp) <- "Mean"
cat("\n")
print(zapsmall(decomp))
cat("\nLinear decomposition:\n")
for (i in 1:3) {
cat(paste("\nWeight: ", names(x$W[i]), "\n"))
decomp <- cbind(Difference = c(x$Q[i], x$U[i]), StdErr = c(sqrt(x$VQ[i]), sqrt(x$VU[i])))
decomp <- cbind(decomp, "z-value" = decomp[, 1] / decomp[, 2])
decomp <- cbind(decomp, "Pr(>|z|)" = 2 * pnorm(-abs(decomp[, 3])))
decomp <- cbind(decomp, c(x$Qa[i], x$Ua[i]))
colnames(decomp) <- c("Difference", "StdErr", "z-value", "Pr(>|z|)", "attendance")
rownames(decomp) <- c("Explained", "Unexplained")
print(zapsmall(decomp))
}
cat("\n")
}
write.oaxaca <- function(x) {
if (class(x) != "oaxaca") stop("Input needs to be of class oaxaca")
#cat(x$mod1, ' ', x$mod2, "\n")
decomp <- matrix(nrow = 3, ncol = 5)
decomp[1, c(1, 2)] <- c(x$R, sqrt(x$VR))
decomp[1, 3] <- c(decomp[1, 1] / decomp[1, 2])
decomp[1, 4] <- c(2 * pnorm(-abs(decomp[1, 3])))
colnames(decomp) <- c("Difference", "StdErr", "z-value", "Pr(>|z|)", paste(x$mod1, x$mod2, sep=''))
if (substr(x$mod1,1,1)=="r") depvar <- "Reading" else if (substr(x$mod1,1,1)=="m") depvar <- "Math"
rownames(decomp) <- c(depvar, "Explained", "Unexplained")
i<-3
decomp[2,1] <- x$Q[i]
decomp[3,1] <- x$U[i]
decomp[2,2] <- sqrt(x$VQ[i])
decomp[3,2] <- sqrt(x$VU[i])
decomp[2,3] <- decomp[2, 1] / decomp[2, 2]
decomp[3,3] <- decomp[3, 1] / decomp[3, 2]
decomp[2,4] <- 2 * pnorm(-abs(decomp[2, 3]))
decomp[3,4] <- 2 * pnorm(-abs(decomp[3, 3]))
decomp[2,5] <- x$Qa[i]
decomp[3,5] <- x$Ua[i]
zapsmall(decomp)
}
detail.oaxaca <- function(x, depth=6) {
if (class(x) != "oaxaca") stop("Input needs to be of class oaxaca")
##only deal with Cotton/Reimers
Qdet <- sort(x$Qdetail[,3])
Udet <- sort(x$Udetail[,3])
Qh <- head(Qdet, depth)
Qt <- tail(Qdet, depth)
Uh <- head(Udet, depth)
Ut <- tail(Udet, depth)
Qsum <- cbind(Qh, names(Qt), Qt)
Usum <- cbind(Uh, names(Ut), Ut)
ret.list <- list(Qsum, Usum)
}
### Below is code specific to the analysis
### which decompositions do we want to do?
### coefcol[-1] lists the options:
### math, reading
### pooled, fixed effects
### racedum1-5, econdum1-4
### remember: race: amerindian, asian, black, hispanic, white
### remember: econ: not poor, free lunch, reduced lunch, other dis
## For pooled and FE models: white-black, white-hispanic, hispanic-black
## notpoor-free, notpoor-reduced, notpoor-other
## This becomes: 5-3, 5-4, 4-3; 1-2, 1-3, 1-4
grouprace <- list(
c('mpa4racedum5C', 'mpa4racedum3C'),
c('rpa4racedum5C', 'rpa4racedum3C'),
c('mfa4racedum5C', 'mfa4racedum3C'),
c('rfa4racedum5C', 'rfa4racedum3C'),
c('mpa4racedum5C', 'mpa4racedum4C'),
c('rpa4racedum5C', 'rpa4racedum4C'),
c('mfa4racedum5C', 'mfa4racedum4C'),
c('rfa4racedum5C', 'rfa4racedum4C'),
c('mpa4racedum4C', 'mpa4racedum3C'),
c('rpa4racedum4C', 'rpa4racedum3C'),
c('mfa4racedum4C', 'mfa4racedum3C'),
c('rfa4racedum4C', 'rfa4racedum3C'))
groupecon <- list(
c('mpa4econdum1C', 'mpa4econdum2C'),
c('rpa4econdum1C', 'rpa4econdum2C'),
c('mfa4econdum1C', 'mfa4econdum2C'),
c('rfa4econdum1C', 'rfa4econdum2C'),
c('mpa4econdum1C', 'mpa4econdum3C'),
c('rpa4econdum1C', 'rpa4econdum3C'),
c('mfa4econdum1C', 'mfa4econdum3C'),
c('rfa4econdum1C', 'rfa4econdum3C'),
c('mpa4econdum1C', 'mpa4econdum4C'),
c('rpa4econdum1C', 'rpa4econdum4C'),
c('mfa4econdum1C', 'mfa4econdum4C'),
c('rfa4econdum1C', 'rfa4econdum4C'))
oax.race<-lapply(grouprace, oaxaca)
oax.econ<-lapply(groupecon, oaxaca)
## oaxaca print out function
lapply(oax.race, write.oaxaca)
lapply(oax.econ, write.oaxaca)
## print out detailed decomposition
race.det <- lapply(oax.race, detail.oaxaca)
names(race.det) <- sapply(grouprace, function(x) paste(x, collapse=''))
race.det
econ.det <- lapply(oax.econ, detail.oaxaca)
names(econ.det) <- sapply(groupecon, function(x) paste(x, collapse=''))
econ.det
|
Formal statement is: lemma IVT': fixes f :: "'a::linear_continuum_topology \<Rightarrow> 'b::linorder_topology" assumes y: "f a \<le> y" "y \<le> f b" "a \<le> b" and *: "continuous_on {a .. b} f" shows "\<exists>x. a \<le> x \<and> x \<le> b \<and> f x = y" Informal statement is: If $f$ is a continuous function on a closed interval $[a,b]$ and $y$ is a number between $f(a)$ and $f(b)$, then there is a number $x$ between $a$ and $b$ such that $f(x) = y$. |
function [gk] = tapas_trans_mv2gk(mu, sigma2)
%% Transforms to the scaling of the gamma distribution%
% Input
% mu -- Means
% sigma2 -- Variance
%
% Output
% gk -- K parameter of an inverse gamma distribution
% [email protected]
% copyright (C) 2015
%
gk = mu.^2 ./ sigma2;
end |
// Copyright (c) 2005 - 2014 Marc de Kamps
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// If you use this software in work leading to a scientific publication, you should include a reference there to
// the 'currently valid reference', which can be found at http://miind.sourceforge.net
#ifndef _CODE_LIBS_GEOMLIB_GEOMALGORITHM_INCLUDE_GUARD
#define _CODE_LIBS_GEOMLIB_GEOMALGORITHM_INCLUDE_GUARD
#include <boost/circular_buffer.hpp>
#include <MPILib/include/AlgorithmInterface.hpp>
#include "GeomParameter.hpp"
#include "NumericalMasterEquationCode.hpp"
namespace GeomLib {
//! Population density algorithm based on Geometric binning: http://arxiv.org/abs/1309.1654
//! Population density techniques are used to model neural populations. See
//! http://link.springer.com/article/10.1023/A:1008964915724 for an introduction.
//! This algorithm uses a geometric binning scheme as described in http://arxiv.org/abs/1309.1654 .
//! The rest of this comment will describe the interaction with the MIIND framework and the
//! objects that it requires.
//! \section label_geom_intro Introduction
//! GeomAlgorithm inherits from AlgorithmInterface. This implies that a node in an MPINetwork
//! can be configured with this algorithm, and that network simulations can be run, where
//! each node represents a neuronal population. The simulations are equivalent to spiking neuron
//! simulations of point model neurons, such as performed by NEST, with some caveats. GeomAlgorithm
//! deals with one dimensional point models, such as leaky-integrate-and-fire, quadratic-integrate-and-fire
//! and exponential-integrate-and-fire. 2D models such adaptive-exponential-integrate-and-fire and conductance
//! based models will be handled by another algorithm, which is in alpha stage. GeomAlgorithm
//! is instantiated using a GeomParameter, which specifies, among other things, the neuronal model
//! and its parameter values, in the form of an AbstractOdeSystem. From the user perspective, this is
//! the most important, and the documentation of AbstractOdeSystem, and more the important the
//! <a href="http://miind.sf.net/tutorial.pdf">MIIND tutorial</a> is the first port of call. In the remainder
//! of this documentation section the interaction of GeomAlgorithm with other objects will be discussed.
//!
//! \section label_geom_initialization The Initialization Sequence
//!
//! The creation sequence is lengthy although the user only sees the first two stages, represented in blue.
//! NeuronParameter defines quantities common to most neuronal models, such as membrane potential,
//! membrane time constant, threshold, etc. OdeParameter accepts a NeuronParameter, and other parameters
//! that set the dimension of the grid. LifNeuralDynamics defines the neuronal model itself in terms of
//! a method LifNeuralDynamics::EvolvePotential(MPILib::Potential,MPILib::Time), which describes
//! how a potential evolves over time under the dynamics of the neuronal model, in this case leaky-integrate-and
//! fire dynamics. For most users the dynamics of a model will already have been defined. The introduction
//! of novel dynamics requires an overload of the corresponding function of AbstractNeuralDynamics.
//! LifOdeSystem is a representation of the grid itself. Note that for spiking neural dynamics another
//! grid representation is needed: SpikingNeuralDynamics. This difference will be removed in the future.
//! The constructor call requires the following initialization sequence.
//! \msc["Main loop"]
//! NeuronParameter, OdeParameter, LifNeuralDynamics, LifOdeSystem, GeomParameter;
//!
//! NeuronParameter=>OdeParameter [label="argument", linecolor="blue"];
//! OdeParameter=>LifNeuralDynamics[label="argument", linecolor="blue"];
//! LifNeuralDynamics=>LifOdeSystem[label="argument"];
//! LifOdeSystem=>GeomParameter[label="argument"];
//! \endmsc
//!
//! section label_geom_creation The Creation Sequence
template <class WeightValue>
class GeomAlgorithm : public AlgorithmInterface<WeightValue> {
public:
typedef GeomParameter Parameter;
using AlgorithmInterface<WeightValue>::evolveNodeState;
//! Standard way for user to create algorithm
GeomAlgorithm
(
const GeomParameter&
);
//! Copy constructor
GeomAlgorithm(const GeomAlgorithm&);
//! virtual destructor
virtual ~GeomAlgorithm();
/**
* Cloning operation, to provide each DynamicNode with its own
* Algorithm instance. Clients use the naked pointer at their own risk.
*/
virtual GeomAlgorithm* clone() const;
/**
* Configure the Algorithm
* @param simParam The simulation parameter
*/
virtual void configure(const MPILib::SimulationRunParameter& simParam);
//! Evolve the state of the node, by time t, given input firing rates and weight vector
virtual void evolveNodeState
(
const std::vector<Rate>&, //!< A vector of instantaneous firing rates
const std::vector<WeightValue>&, //!< A vector of efficacies
Time //!< time by which the state should be evolved
);
virtual void prepareEvolve(const std::vector<Rate>&,
const std::vector<WeightValue>&,
const std::vector<MPILib::NodeType>&);
/**
* The current time point
* @return The current time point
*/
virtual MPILib::Time getCurrentTime() const;
/**
* The calculated rate of the node
* @return The rate of the node
*/
virtual MPILib::Rate getCurrentRate() const;
/**
* Stores the algorithm state in a Algorithm Grid
* @return The state of the algorithm
*/
virtual MPILib::AlgorithmGrid getGrid(NodeId, bool b_state = true) const;
private:
bool IsReportDue() const;
const GeomParameter _par_geom;
AlgorithmGrid _grid;
unique_ptr<AbstractOdeSystem> _p_system;
unique_ptr<AbstractMasterEquation> _p_zl;
bool _b_zl;
Time _t_cur;
Time _t_step;
Time _t_report;
mutable Number _n_report;
};
}
#endif // include guard
|
/-
Copyright (c) 2017 Johannes HΓΆlzl. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Johannes HΓΆlzl
Quotient construction on modules
-/
import linear_algebra.basic
import linear_algebra.prod_module
import linear_algebra.subtype_module
universes u v w
variables {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w}
variables [ring Ξ±] [module Ξ± Ξ²] [module Ξ± Ξ³] (s : set Ξ²) [is_submodule s]
include Ξ±
open function
namespace is_submodule
def quotient_rel : setoid Ξ² :=
β¨Ξ»bβ bβ, bβ - bβ β s,
assume b, by simp [zero],
assume bβ bβ hb,
have - (bβ - bβ) β s, from is_submodule.neg hb,
by simpa using this,
assume bβ bβ bβ hbββ hbββ,
have (bβ - bβ) + (bβ - bβ) β s, from add hbββ hbββ,
by simpa using thisβ©
end is_submodule
namespace quotient_module
open is_submodule
section
variable (Ξ²)
/-- Quotient module. `quotient Ξ² s` is the quotient of the module `Ξ²` by the submodule `s`. -/
def quotient (s : set Ξ²) [is_submodule s] : Type v := quotient (quotient_rel s)
end
local notation ` Q ` := quotient Ξ² s
def mk {s : set Ξ²} [is_submodule s] : Ξ² β quotient Ξ² s := quotient.mk'
instance {Ξ±} {Ξ²} {r : ring Ξ±} [module Ξ± Ξ²] (s : set Ξ²) [is_submodule s] : has_coe Ξ² (quotient Ξ² s) := β¨mkβ©
protected def eq {s : set Ξ²} [is_submodule s] {a b : Ξ²} : (a : quotient Ξ² s) = b β a - b β s :=
quotient.eq'
instance quotient.has_zero : has_zero Q := β¨mk 0β©
instance quotient.has_add : has_add Q :=
β¨Ξ»a b, quotient.lift_onβ' a b (Ξ»a b, ((a + b : Ξ² ) : Q)) $
assume aβ aβ bβ bβ (hβ : aβ - bβ β s) (hβ : aβ - bβ β s),
quotient.sound' $
have (aβ - bβ) + (aβ - bβ) β s, from add hβ hβ,
show (aβ + aβ) - (bβ + bβ) β s, by simpaβ©
instance quotient.has_neg : has_neg Q :=
β¨Ξ»a, quotient.lift_on' a (Ξ»a, mk (- a)) $ assume a b (h : a - b β s),
quotient.sound' $
have - (a - b) β s, from neg h,
show (-a) - (-b) β s, by simpaβ©
instance quotient.add_comm_group : add_comm_group Q :=
{ zero := 0,
add := (+),
neg := has_neg.neg,
add_assoc := assume a b c, quotient.induction_onβ' a b c $
assume a b c, quotient_module.eq.2 $
by simp [is_submodule.zero],
add_comm := assume a b, quotient.induction_onβ' a b $
assume a b, quotient_module.eq.2 $ by simp [is_submodule.zero],
add_zero := assume a, quotient.induction_on' a $
assume a, quotient_module.eq.2 $ by simp [is_submodule.zero],
zero_add := assume a, quotient.induction_on' a $
assume a, quotient_module.eq.2 $ by simp [is_submodule.zero],
add_left_neg := assume a, quotient.induction_on' a $
assume a, quotient_module.eq.2 $ by simp [is_submodule.zero] }
instance quotient.has_scalar : has_scalar Ξ± Q :=
β¨Ξ»a b, quotient.lift_on' b (Ξ»b, ((a β’ b : Ξ²) : Q)) $ assume bβ bβ (h : bβ - bβ β s),
quotient.sound' $
have a β’ (bβ - bβ) β s, from is_submodule.smul a h,
show a β’ bβ - a β’ bβ β s, by simpa [smul_add]β©
instance quotient.module : module Ξ± Q :=
{ smul := (β’),
one_smul := assume a, quotient.induction_on' a $
assume a, quotient_module.eq.2 $ by simp [is_submodule.zero],
mul_smul := assume a b c, quotient.induction_on' c $
assume c, quotient_module.eq.2 $ by simp [is_submodule.zero, mul_smul],
smul_add := assume a b c, quotient.induction_onβ' b c $
assume b c, quotient_module.eq.2 $ by simp [is_submodule.zero, smul_add],
add_smul := assume a b c, quotient.induction_on' c $
assume c, quotient_module.eq.2 $ by simp [is_submodule.zero, add_smul], }
@[simp] lemma coe_zero : ((0 : Ξ²) : Q) = 0 := rfl
@[simp] lemma coe_smul (a : Ξ±) (b : Ξ²) : ((a β’ b : Ξ²) : Q) = a β’ b := rfl
@[simp] lemma coe_add (a b : Ξ²) : ((a + b : Ξ²) : Q) = a + b := rfl
lemma coe_eq_zero (b : Ξ²) : (b : quotient Ξ² s) = 0 β b β s :=
by rw [β (coe_zero s), quotient_module.eq]; simp
instance quotient.inhabited : inhabited Q := β¨0β©
lemma is_linear_map_quotient_mk : @is_linear_map _ _ Q _ _ _ (Ξ»b, mk b : Ξ² β Q) :=
by refine {..}; intros; refl
def quotient.lift {f : Ξ² β Ξ³} (hf : is_linear_map f) (h : βxβs, f x = 0) (b : Q) : Ξ³ :=
b.lift_on' f $ assume a b (hab : a - b β s),
have f a - f b = 0, by rw [βhf.sub]; exact h _ hab,
show f a = f b, from eq_of_sub_eq_zero this
@[simp] lemma quotient.lift_mk {f : Ξ² β Ξ³} (hf : is_linear_map f) (h : βxβs, f x = 0) (b : Ξ²) :
quotient.lift s hf h (b : Q) = f b :=
rfl
lemma is_linear_map_quotient_lift {f : Ξ² β Ξ³} {h : βx y, x - y β s β f x = f y}
(hf : is_linear_map f) : is_linear_map (Ξ»q:Q, quotient.lift_on' q f h) :=
β¨assume bβ bβ, quotient.induction_onβ' bβ bβ $ assume bβ bβ, hf.add bβ bβ,
assume a b, quotient.induction_on' b $ assume b, hf.smul a bβ©
lemma quotient.injective_lift [is_submodule s] {f : Ξ² β Ξ³} (hf : is_linear_map f)
(hs : s = {x | f x = 0}) : injective (quotient.lift s hf $ le_of_eq hs) :=
assume a b, quotient.induction_onβ' a b $ assume a b (h : f a = f b), quotient.sound' $
have f (a - b) = 0, by rw [hf.sub]; simp [h],
show a - b β s, from hs.symm βΈ this
lemma quotient.exists_rep {s : set Ξ²} [is_submodule s] : β q : quotient Ξ² s, β b : Ξ², mk b = q :=
@_root_.quotient.exists_rep _ (quotient_rel s)
section vector_space
variables {Ξ±' : Type u} {Ξ²' : Type v}
variables [field Ξ±'] [vector_space Ξ±' Ξ²'] (s' : set Ξ²') [is_submodule s']
omit Ξ±
include Ξ±'
instance quotient.vector_space : vector_space Ξ±' (quotient Ξ²' s') := {}
theorem quotient_prod_linear_equiv :
nonempty ((quotient_module.quotient Ξ²' s' Γ s') ββ Ξ²') :=
let β¨g, H1, H2β© := exists_right_inverse_linear_map_of_surjective
(quotient_module.is_linear_map_quotient_mk s')
(quotient_module.quotient.exists_rep) in
have H3 : β b, quotient_module.mk (g b) = b := Ξ» b, congr_fun H2 b,
β¨{ to_fun := Ξ» b, g b.1 + b.2.1,
inv_fun := Ξ» b, (quotient_module.mk b, β¨b - g (quotient_module.mk b),
(quotient_module.coe_eq_zero _ _).1 $
((quotient_module.is_linear_map_quotient_mk _).sub _ _).trans $
by rw [H3, sub_self]β©),
left_inv := Ξ» β¨q, b, hβ©,
have H4 : quotient_module.mk b = 0,
from (quotient_module.coe_eq_zero s' b).2 h,
have H5 : quotient_module.mk (g q + b) = q,
from ((quotient_module.is_linear_map_quotient_mk _).add _ _).trans $
by simp only [H3, H4, add_zero],
prod.ext H5 (subtype.eq $ by simp only [H5, add_sub_cancel']),
right_inv := Ξ» b, add_sub_cancel'_right _ _,
linear_fun := β¨Ξ» β¨q1, b1, h1β© β¨q2, b2, h2β©,
show g (q1 + q2) + (b1 + b2) = (g q1 + b1) + (g q2 + b2),
by rw [H1.add]; simp only [add_left_comm, add_assoc],
Ξ» c β¨q, b, hβ©, show g (c β’ q) + (c β’ b) = c β’ (g q + b),
by rw [H1.smul, smul_add]β© }β©
end vector_space
end quotient_module
|
lemma pseudo_divmod_field: fixes g :: "'a::field poly" assumes g: "g \<noteq> 0" and *: "pseudo_divmod f g = (q,r)" defines "c \<equiv> coeff g (degree g) ^ (Suc (degree f) - degree g)" shows "f = g * smult (1/c) q + smult (1/c) r" |
module local_routines
!!
!! Setup the Merewether problem.
!!
use global_mod, only: dp, ip, force_double, charlen, wall_elevation, pi
use domain_mod, only: domain_type, STG, UH, VH, ELV
use read_raster_mod, only: read_gdal_raster
use which_mod, only: which
use ragged_array_mod, only: ragged_array_2d_ip_type
use file_io_mod, only: read_character_file, read_csv_into_array
use points_in_poly_mod, only: points_in_poly
use iso_c_binding, only: c_f_pointer, c_loc
implicit none
! Add rain
! Discharge of 19.7 m^3/s occurs over a cirle with radius 15
real(dp), parameter :: rain_centre(2) = [382300.0_dp, 6354290.0_dp], rain_radius = 15.0_dp
real(force_double) :: rain_rate = real(19.7_dp, force_double)/(pi * rain_radius**2)
integer(ip) :: num_input_discharge_cells
contains
!
! Main setup routine
!
subroutine set_initial_conditions_merewether(domain, reflective_boundaries)
class(domain_type), target, intent(inout):: domain
logical, intent(in):: reflective_boundaries
integer(ip):: i, j, k
real(dp), allocatable:: x(:,:), y(:,:)
character(len=charlen):: input_elevation_file, polygon_filename
! Add this elevation to all points in houses/ csv polygons
real(dp), parameter:: house_height = 3.0_dp
! friction parameters
real(dp), parameter:: friction_road = 0.02_dp, friction_other = 0.04_dp
! things to help read polygons
character(len=charlen), allocatable:: house_filenames(:)
integer(ip):: house_file_unit, inside_point_counter, house_cell_count
real(dp), allocatable:: polygon_coords(:,:)
logical, allocatable:: is_inside_poly(:)
type(ragged_array_2d_ip_type), pointer :: rainfall_region_indices
integer(ip), allocatable :: i_inside(:)
allocate(x(domain%nx(1),domain%nx(2)), y(domain%nx(1),domain%nx(2)))
!
! Dry flow to start with. Later we clip stage to elevation.
!
domain%U(:,:,[STG, UH, VH]) = 0.0_dp
!
! Set elevation with the raster
!
input_elevation_file = "./topography/topography1.tif"
do j = 1, domain%nx(2)
do i = 1, domain%nx(1)
x(i,j) = domain%lower_left(1) + (i-0.5_dp)*domain%dx(1)
y(i,j) = domain%lower_left(2) + (j-0.5_dp)*domain%dx(2)
end dO
end do
call read_gdal_raster(input_elevation_file, x, y, domain%U(:,:,ELV), &
domain%nx(1)*domain%nx(2), verbose=1_ip, bilinear=0_ip)
print*, 'Elevation range: ', minval(domain%U(:,:,ELV)), maxval(domain%U(:,:,ELV))
! Get filenames for the houses
open(newunit = house_file_unit, file='houses_filenames.txt')
call read_character_file(house_file_unit, house_filenames, "(A)")
close(house_file_unit)
! Read the houses and add house_height to the elevation for all points inside
allocate(is_inside_poly(domain%nx(1)))
house_cell_count = 0
do k = 1, size(house_filenames)
inside_point_counter = 0
polygon_filename = './' // TRIM(house_filenames(k))
call read_csv_into_array(polygon_coords, polygon_filename)
do j = 1, domain%nx(2)
! Find points in the polygon in column j
call points_in_poly(polygon_coords(1,:), polygon_coords(2,:), x(:,j), y(:,j), is_inside_poly)
inside_point_counter = inside_point_counter + count(is_inside_poly)
do i = 1, domain%nx(1)
if(is_inside_poly(i)) then
domain%U(i,j,ELV) = domain%U(i,j,ELV) + house_height
house_cell_count = house_cell_count + 1_ip
end if
end do
end do
print*, trim(house_filenames(k)), ': ', inside_point_counter
end do
print*, '# cells in houses: ', house_cell_count
if(reflective_boundaries) then
! Walls all sides
domain%U(1,:,ELV) = wall_elevation
domain%U(domain%nx(1), :, ELV) = wall_elevation
domain%U(:, 1 ,ELV) = wall_elevation
domain%U(:, domain%nx(2), ELV) = wall_elevation
else
! Transmissive outflow -- but we prevent mass leaking out of the back of the domain.
! Also block off other sides -- only need outflow on east edge of domain.
domain%U(:, 1:2, ELV) = domain%U(:,1:2, ELV) + 10.0_dp
domain%U(1:2, :, ELV) = domain%U(1:2, :, ELV) + 10.0_dp
domain%U(:, (domain%nx(2)-1):domain%nx(2), ELV) = 10.0_dp + &
domain%U(:, (domain%nx(2)-1):domain%nx(2), ELV)
end if
!
! Set friction
!
! Initial value -- later updated based on roads
domain%manning_squared = friction_other * friction_other
! Find points in road polygon and set friction there
polygon_filename = 'Road/RoadPolygon.csv'
call read_csv_into_array(polygon_coords, polygon_filename)
inside_point_counter = 0
do j = 1, domain%nx(2)
call points_in_poly(polygon_coords(1,:), polygon_coords(2,:), x(:,j), y(:,j), is_inside_poly)
inside_point_counter = inside_point_counter + count(is_inside_poly)
do i = 1, domain%nx(1)
if(is_inside_poly(i)) domain%manning_squared(i,j) = friction_road * friction_road
end do
end do
print*, ''
print*, '# Points in road polygon :', inside_point_counter
print*, ''
! Ensure stage >= elevation
domain%U(:,:,STG) = max(domain%U(:,:,STG), domain%U(:,:,ELV) + 1.0e-08_dp)
print*, 'Elevation range: ', minval(domain%U(:,:,ELV)), maxval(domain%U(:,:,ELV))
print*, 'Stage range: ', minval(domain%U(:,:,STG)), maxval(domain%U(:,:,STG))
! Figure out indices that are inside the rainfall forcing region.
allocate(rainfall_region_indices)
allocate(rainfall_region_indices%i2(domain%nx(2)))
num_input_discharge_cells = 0
do j = 1, domain%nx(2)
! Find cells in this row that are within the rain circle
call which( (domain%x - rain_centre(1))**2 < rain_radius**2 - (domain%y(j) - rain_centre(2))**2, &
rainfall_region_indices%i2(j)%i1)
! For this routine we cross-check conservation by counting the number of input discharge cells and
! doing a separate mass balance. This assumes 1 domain (only)
num_input_discharge_cells = num_input_discharge_cells + size(rainfall_region_indices%i2(j)%i1)
end do
domain%forcing_context_cptr = c_loc(rainfall_region_indices)
end subroutine
!
! This is the discharge source term, called every time-step. It's like rainfall
! in a "circle"
!
subroutine apply_rainfall_forcing(domain, dt)
type(domain_type), intent(inout) :: domain
real(dp), intent(in) :: dt
integer(ip) :: j
type(ragged_array_2d_ip_type), pointer :: rainfall_region_indices
! Unpack the forcing context pointer. In this case it is a ragged array giving the indices
! where we should apply the rainfall in this domain
call c_f_pointer(domain%forcing_context_cptr, rainfall_region_indices)
!$OMP PARALLEL DEFAULT(PRIVATE) SHARED(domain, rain_rate, dt, rainfall_region_indices)
!$OMP DO SCHEDULE(STATIC)
do j = 1, domain%nx(2)
if(size(rainfall_region_indices%i2(j)%i1) > 0) then
! Rainfall at cells within a circle of radius "rain_radius" about "rain_centre"
domain%U( rainfall_region_indices%i2(j)%i1, j,STG) = rain_rate * dt + &
domain%U(rainfall_region_indices%i2(j)%i1, j,STG)
end if
end do
!$OMP END DO
!$OMP END PARALLEL
end subroutine
end module
!@!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
program merewether
!! Urban flooding test case in Merewether from Australian Rainfall and Runoff.
!! Smith, G. & Wasko, C. Revision Project 15: Two Dimensional Simulations In
!! Urban Areas - Representation of Buildings in 2D Numerical Flood Models Australian
!! Rainfall and Runoff, Engineers Australia, 2012
use global_mod, only: ip, dp, minimum_allowed_depth
use domain_mod, only: domain_type
use boundary_mod, only: transmissive_boundary
use local_routines
implicit none
integer(ip):: j
real(dp):: last_write_time
type(domain_type):: domain
! Approx timestep between outputs
real(dp), parameter :: approximate_writeout_frequency = 60.0_dp
real(dp), parameter :: final_time = 900.0_dp
! Length/width
real(dp), parameter, dimension(2):: global_lw = [320.0_dp, 415.0_dp]
! Lower-left corner coordinate
real(dp), parameter, dimension(2):: global_ll = [382251.0_dp, 6354266.5_dp]
! grid size (number of x/y cells)
integer(ip), parameter, dimension(2):: global_nx = [320_ip, 415_ip] ![160_ip, 208_ip] ![321_ip, 416_ip]
! Use reflective or transmissive boundaries
logical, parameter:: reflective_boundaries = .FALSE.
! Track mass
real(force_double) :: volume_added, volume_initial
! Use a small time step at the start
real(dp) :: startup_timestep = 0.05_dp
real(dp) :: startup_time = 10.0_dp
domain%timestepping_method = 'rk2n' !'euler' !'rk2n'
! Use a very small maximum timestep initially, because the domain is dry, but water is quickly
! added, which can cause 'first-step' instability otherwise. Re-set it after an evolve
call domain%allocate_quantities(global_lw, global_nx, global_ll)
if((.not. reflective_boundaries) .and. (.not. all(domain%is_nesting_boundary))) then
! Allow waves to propagate outside all edges
domain%boundary_subroutine => transmissive_boundary
end if
! Add rainfall to the domain
domain%forcing_subroutine => apply_rainfall_forcing
! Call local routine to set initial conditions
call set_initial_conditions_merewether(domain, reflective_boundaries)
call domain%update_boundary()
volume_initial = domain%mass_balance_interior()
! Trick to get the code to write out just after the first timestep
last_write_time = -approximate_writeout_frequency
! Evolve the code
do while (.TRUE.)
if(domain%time - last_write_time >= approximate_writeout_frequency) then
last_write_time = last_write_time + approximate_writeout_frequency
call domain%print()
call domain%write_to_output_files()
print*, 'mass_balance: ', domain%mass_balance_interior()
print*, 'volume_added + initial: ', volume_added + volume_initial
print*, '.... difference: ', domain%mass_balance_interior() - (volume_added + volume_initial)
end if
if (domain%time > final_time) then
exit
end if
! At the start, evolve with a specified (small) timestep.
! Later allow an adaptive step
if(domain%time < startup_time) then
call domain%evolve_one_step(startup_timestep)
else
call domain%evolve_one_step()
end if
! Track volume added 'in theory' based on the known rainfall rate that is going into
! a known number of cells
volume_added = domain%time * rain_rate * num_input_discharge_cells * product(domain%dx)
!print*, 'negative_depth_fix_counter: ', domain%negative_depth_fix_counter
end do
call domain%write_max_quantities()
! Print timing info
call domain%timer%print()
! Simple test (mass conservation only)
print*, 'MASS CONSERVATION TEST'
if(abs(domain%mass_balance_interior() - (volume_added + volume_initial) ) < 1.0e-06_dp) then
print*, 'PASS'
else
print*, 'FAIL -- mass conservation not good enough. ', &
'This is expected with single precision, which will affect the computed direct rainfall volumes'
end if
call domain%finalise()
END PROGRAM
|
-- {-# OPTIONS -v tc.term.exlam:100 -v extendedlambda:100 -v int2abs.reifyterm:100 #-}
-- Andreas, 2013-02-26
module Issue778 (Param : Set) where
data β₯ : Set where
interactive : β₯ β β₯
interactive = Ξ» {x β {!x!}}
where aux : β₯ β β₯
aux x = x
-- splitting did not work for extended lambda in the presence of
-- module parameters and where block
data β€ : Set where
tt : β€
test : β€ β β€
test = Ξ» { x β {!x!} }
where aux : β€ β β€
aux x = x
|
/*
* This file is a part of the TChecker project.
*
* See files AUTHORS and LICENSE for copyright details.
*
*/
#ifndef TCHECKER_TA_HH
#define TCHECKER_TA_HH
#include <cstdlib>
#include <boost/dynamic_bitset.hpp>
#include "tchecker/basictypes.hh"
#include "tchecker/syncprod/syncprod.hh"
#include "tchecker/syncprod/vedge.hh"
#include "tchecker/syncprod/vloc.hh"
#include "tchecker/ta/allocators.hh"
#include "tchecker/ta/state.hh"
#include "tchecker/ta/system.hh"
#include "tchecker/ta/transition.hh"
#include "tchecker/utils/shared_objects.hh"
#include "tchecker/variables/clocks.hh"
#include "tchecker/variables/intvars.hh"
/*!
\file ta.hh
\brief Timed automata
*/
namespace tchecker {
namespace ta {
/*!
\brief Type of iterator over initial states
*/
using initial_iterator_t = tchecker::syncprod::initial_iterator_t;
/*!
\brief Type of range of iterators over inital states
*/
using initial_range_t = tchecker::syncprod::initial_range_t;
/*!
\brief Accessor to initial edges
\param system : a system
\return initial edges
*/
inline tchecker::ta::initial_range_t initial_edges(tchecker::ta::system_t const & system)
{
return tchecker::syncprod::initial_edges(system.as_syncprod_system());
}
/*!
\brief Dereference type for iterator over initial states
*/
using initial_value_t = tchecker::syncprod::initial_value_t;
/*!
\brief Compute initial state
\param system : a system
\param vloc : tuple of locations
\param intval : valuation of bounded integer variables
\param vedge : tuple of edges
\param invariant : clock constraint container for initial state invariant
\param initial_range : range of initial state valuations
\pre the size of vloc and vedge is equal to the size of initial_range.
initial_range has been obtained from system.
initial_range yields the initial locations of all the processes ordered by increasing process identifier
\post vloc has been initialized to the tuple of initial locations in initial_range,
intval has been initialized to the initial valuation of bounded integer variables,
vedge has been initialized to an empty tuple of edges.
clock constraints from initial_range invariant have been aded to invariant
\return tchecker::STATE_OK if initialization succeeded
STATE_SRC_INVARIANT_VIOLATED if the initial valuation of integer variables does not satisfy invariant
\throw std::runtime_error : if evaluation of invariant throws an exception
*/
tchecker::state_status_t initial(tchecker::ta::system_t const & system,
tchecker::intrusive_shared_ptr_t<tchecker::shared_vloc_t> const & vloc,
tchecker::intrusive_shared_ptr_t<tchecker::shared_intval_t> const & intval,
tchecker::intrusive_shared_ptr_t<tchecker::shared_vedge_t> const & vedge,
tchecker::clock_constraint_container_t & invariant,
tchecker::ta::initial_value_t const & initial_range);
/*!
\brief Compute initial state and transition
\param system : a system
\param s : state
\param t : transition
\param v : initial iterator value
\post s has been initialized from v, and t is an empty transition
\return tchecker::STATE_OK
\throw std::invalid_argument : if s and v have incompatible sizes
*/
inline tchecker::state_status_t initial(tchecker::ta::system_t const & system, tchecker::ta::state_t & s,
tchecker::ta::transition_t & t, tchecker::ta::initial_value_t const & v)
{
return tchecker::ta::initial(system, s.vloc_ptr(), s.intval_ptr(), t.vedge_ptr(), t.tgt_invariant_container(), v);
}
/*!
\brief Type of iterator over outgoing edges
*/
using outgoing_edges_iterator_t = tchecker::syncprod::outgoing_edges_iterator_t;
/*!
\brief Type of range of outgoing edges
*/
using outgoing_edges_range_t = tchecker::syncprod::outgoing_edges_range_t;
/*!
\brief Accessor to outgoing edges
\param system : a system
\param vloc : tuple of locations
\return range of outgoing synchronized and asynchronous edges from vloc in system
*/
inline tchecker::ta::outgoing_edges_range_t
outgoing_edges(tchecker::ta::system_t const & system,
tchecker::intrusive_shared_ptr_t<tchecker::shared_vloc_t const> const & vloc)
{
return tchecker::syncprod::outgoing_edges(system.as_syncprod_system(), vloc);
}
/*!
\brief Type of outgoing vedge (range of synchronized/asynchronous edges)
*/
using outgoing_edges_value_t = tchecker::syncprod::outgoing_edges_value_t;
/*!
\brief Compute next state
\param system : a system
\param vloc : tuple of locations
\param intval : valuation of bounded integer variables
\param vedge : tuple of edges
\param src_invariant : clock constraint container for invariant of vloc before it is updated
\param guard : clock constraint container for guard of vedge
\param reset : clock resets container for clock resets of vedge
\param tgt_invariant : clock constaint container for invariant of vloc after it is updated
\param edges : tuple of edge from vloc (range of synchronized/asynchronous edges)
\pre the source location in edges match the locations in vloc.
No process has more than one edge in edges.
The pid of every process in edges is less than the size of vloc
\post the locations in vloc have been updated to target locations of the
processes involved in edges, and they have been left unchanged for the other processes.
The values of variables in intval have been updated according to the statements in edges.
Clock constraints from the invariants of vloc before it is updated have been pushed to src_invariant.
Clock constraints from the guards in edges have been pushed into guard.
Clock resets from the statements in edges have been pushed into reset.
And clock constraints from the invariants in the updated vloc have been pushed into tgt_invariant
\return STATE_OK if state computation succeeded,
STATE_INCOMPATIBLE_EDGE if the source locations in edges do not match vloc,
STATE_SRC_INVARIANT_VIOLATED if the valuation intval does not satisfy the invariant in vloc,
STATE_GUARD_VIOLATED if the values in intval do not satisfy the guard of edges,
STATE_STATEMENT_FAILED if statements in edges cannot be applied to intval
STATE_TGT_INVARIANT_VIOLATED if the updated intval does not satisfy the invariant of updated vloc.
\throw std::invalid_argument : if a pid in edges is greater or equal to the size of vloc
\throw std::runtime_error : if the guard in edges generates clock resets, or if the statements in edges generate clock
constraints, or if the invariant in updated vloc generates clock resets
\throw std::runtime_error : if evaluation of invariants, guards or statements throws an exception
*/
tchecker::state_status_t next(tchecker::ta::system_t const & system,
tchecker::intrusive_shared_ptr_t<tchecker::shared_vloc_t> const & vloc,
tchecker::intrusive_shared_ptr_t<tchecker::shared_intval_t> const & intval,
tchecker::intrusive_shared_ptr_t<tchecker::shared_vedge_t> const & vedge,
tchecker::clock_constraint_container_t & src_invariant,
tchecker::clock_constraint_container_t & guard, tchecker::clock_reset_container_t & reset,
tchecker::clock_constraint_container_t & tgt_invariant,
tchecker::ta::outgoing_edges_value_t const & edges);
/*!
\brief Compute next state and transition
\param system : a system
\param s : state
\param t : transition
\param v : outgoing edge value
\post s have been updated from v, and t is the set of edges in v
\return status of state s after update
\throw std::invalid_argument : if s and v have incompatible size
*/
inline tchecker::state_status_t next(tchecker::ta::system_t const & system, tchecker::ta::state_t & s,
tchecker::ta::transition_t & t, tchecker::ta::outgoing_edges_value_t const & v)
{
return tchecker::ta::next(system, s.vloc_ptr(), s.intval_ptr(), t.vedge_ptr(), t.src_invariant_container(),
t.guard_container(), t.reset_container(), t.tgt_invariant_container(), v);
}
/*!
\brief Checks if time can elapse in a tuple of locations
\param system : a system of timed processes
\param vloc : tuple of locations
\return true if time delay is allowed in vloc, false otherwise
*/
bool delay_allowed(tchecker::ta::system_t const & system, tchecker::vloc_t const & vloc);
/*!
\brief Compute the set of reference clocks that can let time elapse in a tuple
of locations
\param system : a system of timed processes
\param r : reference clocks
\param vloc : tuple of locations
\return a dynamic bitset of size r.refcount() that contains all reference clocks
that can delay from vloc
*/
boost::dynamic_bitset<> delay_allowed(tchecker::ta::system_t const & system, tchecker::reference_clock_variables_t const & r,
tchecker::vloc_t const & vloc);
/*!
\brief Compute the set of reference clocks that should synchronize on a tuple
of edges
\param system : a system of timed processes
\param r : reference clocks
\param vedge : tuple of edges
\return a dynamic bitset of size r.refcount() that contains all reference
clocks that should synchronize on vedge
*/
boost::dynamic_bitset<> sync_refclocks(tchecker::ta::system_t const & system, tchecker::reference_clock_variables_t const & r,
tchecker::vedge_t const & vedge);
/*!
\brief Checks if a state satisfies a set of labels
\param system : a system of timed processes
\param s : a state
\param labels : a set of labels
\return true if labels is not empty and labels is included in the set of
labels of state s, false otherwise
*/
bool satisfies(tchecker::ta::system_t const & system, tchecker::ta::state_t const & s, boost::dynamic_bitset<> const & labels);
/*!
\brief Accessor to state attributes as strings
\param system : a system
\param s : a state
\param m : a map of string pairs (key, value)
\post the tuple of locations and integer variables valuation in s have been
added to map m
*/
void attributes(tchecker::ta::system_t const & system, tchecker::ta::state_t const & s, std::map<std::string, std::string> & m);
/*!
\brief Accessor to transition attributes as strings
\param system : a system
\param t : a transition
\param m : a map of string pairs (key, value)
\post the tuple of edges in t has been added to map m
*/
void attributes(tchecker::ta::system_t const & system, tchecker::ta::transition_t const & t,
std::map<std::string, std::string> & m);
/*!
\class ta_t
\brief Timed automaton over a system of synchronized timed processes
*/
class ta_t final : public tchecker::ts::full_ts_t<tchecker::ta::state_sptr_t, tchecker::ta::const_state_sptr_t,
tchecker::ta::transition_sptr_t, tchecker::ta::const_transition_sptr_t,
tchecker::ta::initial_range_t, tchecker::ta::outgoing_edges_range_t,
tchecker::ta::initial_value_t, tchecker::ta::outgoing_edges_value_t> {
public:
/*!
\brief Constructor
\param system : a system of timed processes
\param block_size : number of objects allocated in a block
\note all states and transitions are pool allocated and deallocated automatically
*/
ta_t(std::shared_ptr<tchecker::ta::system_t const> const & system, std::size_t block_size);
/*!
\brief Copy constructor (deleted)
*/
ta_t(tchecker::ta::ta_t const &) = delete;
/*!
\brief Move constructor (deleted)
*/
ta_t(tchecker::ta::ta_t &&) = delete;
/*!
\brief Destructor
*/
virtual ~ta_t() = default;
/*!
\brief Assignment operator (deleted)
*/
tchecker::ta::ta_t & operator=(tchecker::ta::ta_t const &) = delete;
/*!
\brief Move-assignment operator (deleted)
*/
tchecker::ta::ta_t & operator=(tchecker::ta::ta_t &&) = delete;
using tchecker::ts::full_ts_t<tchecker::ta::state_sptr_t, tchecker::ta::const_state_sptr_t, tchecker::ta::transition_sptr_t,
tchecker::ta::const_transition_sptr_t, tchecker::ta::initial_range_t,
tchecker::ta::outgoing_edges_range_t, tchecker::ta::initial_value_t,
tchecker::ta::outgoing_edges_value_t>::status;
using tchecker::ts::full_ts_t<tchecker::ta::state_sptr_t, tchecker::ta::const_state_sptr_t, tchecker::ta::transition_sptr_t,
tchecker::ta::const_transition_sptr_t, tchecker::ta::initial_range_t,
tchecker::ta::outgoing_edges_range_t, tchecker::ta::initial_value_t,
tchecker::ta::outgoing_edges_value_t>::state;
using tchecker::ts::full_ts_t<tchecker::ta::state_sptr_t, tchecker::ta::const_state_sptr_t, tchecker::ta::transition_sptr_t,
tchecker::ta::const_transition_sptr_t, tchecker::ta::initial_range_t,
tchecker::ta::outgoing_edges_range_t, tchecker::ta::initial_value_t,
tchecker::ta::outgoing_edges_value_t>::transition;
/*!
\brief Accessor
\return range of initial edges
*/
virtual tchecker::ta::initial_range_t initial_edges();
/*!
\brief Initial state and transition
\param init_edge : initial state valuation
\param v : container
\post triples (status, s, t) have been added to v, for each initial state s
and initial transition t that are initialized from init_edge.
*/
virtual void initial(tchecker::ta::initial_value_t const & init_edge, std::vector<sst_t> & v);
/*!
\brief Accessor
\param s : state
\return outgoing edges from state s
*/
virtual tchecker::ta::outgoing_edges_range_t outgoing_edges(tchecker::ta::const_state_sptr_t const & s);
/*!
\brief Next state and transition
\param s : state
\param out_edge : outgoing edge value
\param v : container
\post triples (status, s', t') have been added to v, for each successor state
s' and transition t from s to s' along outgoing edge out_edge
*/
virtual void next(tchecker::ta::const_state_sptr_t const & s, tchecker::ta::outgoing_edges_value_t const & out_edge,
std::vector<sst_t> & v);
using tchecker::ts::full_ts_t<tchecker::ta::state_sptr_t, tchecker::ta::const_state_sptr_t, tchecker::ta::transition_sptr_t,
tchecker::ta::const_transition_sptr_t, tchecker::ta::initial_range_t,
tchecker::ta::outgoing_edges_range_t, tchecker::ta::initial_value_t,
tchecker::ta::outgoing_edges_value_t>::initial;
using tchecker::ts::full_ts_t<tchecker::ta::state_sptr_t, tchecker::ta::const_state_sptr_t, tchecker::ta::transition_sptr_t,
tchecker::ta::const_transition_sptr_t, tchecker::ta::initial_range_t,
tchecker::ta::outgoing_edges_range_t, tchecker::ta::initial_value_t,
tchecker::ta::outgoing_edges_value_t>::next;
/*!
\brief Checks if a state satisfies a set of labels
\param s : a state
\param labels : a set of labels
\return true if labels is not empty and labels is included in the set of
labels of state s, false otherwise
*/
virtual bool satisfies(tchecker::ta::const_state_sptr_t const & s, boost::dynamic_bitset<> const & labels) const;
/*!
\brief Accessor to state attributes as strings
\param s : a state
\param m : a map of string pairs (key, value)
\post attributes of state s have been added to map m
*/
virtual void attributes(tchecker::ta::const_state_sptr_t const & s, std::map<std::string, std::string> & m) const;
/*!
\brief Accessor to transition attributes as strings
\param t : a transition
\param m : a map of string pairs (key, value)
\post attributes of transition t have been added to map m
*/
virtual void attributes(tchecker::ta::const_transition_sptr_t const & t, std::map<std::string, std::string> & m) const;
/*!
\brief Accessor
\return Underlying system of timed processes
*/
tchecker::ta::system_t const & system() const;
private:
std::shared_ptr<tchecker::ta::system_t const> _system; /*!< System of timed processes */
tchecker::ta::state_pool_allocator_t _state_allocator; /*!< Pool allocator of states */
tchecker::ta::transition_pool_allocator_t _transition_allocator; /*! Pool allocator of transitions */
};
} // end of namespace ta
} // end of namespace tchecker
#endif // TCHECKER_TA_HH
|
/*******************************************************************************
* Copyright (c) 2015-2018 Skymind, Inc.
*
* This program and the accompanying materials are made available under the
* terms of the Apache License, Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
* SPDX-License-Identifier: Apache-2.0
******************************************************************************/
//
// @author [email protected]
//
#ifndef LIBND4J_BLAS_HELPER_H
#define LIBND4J_BLAS_HELPER_H
#include <system/pointercast.h>
#include <types/float16.h>
#include <cblas.h>
#include <helpers/logger.h>
#ifdef _WIN32
#define CUBLASWINAPI __stdcall
#define CUSOLVERAPI __stdcall
#else
#define CUBLASWINAPI
#define CUSOLVERAPI
#endif
namespace sd {
typedef enum{
CUBLAS_STATUS_SUCCESS =0,
CUBLAS_STATUS_NOT_INITIALIZED =1,
CUBLAS_STATUS_ALLOC_FAILED =3,
CUBLAS_STATUS_INVALID_VALUE =7,
CUBLAS_STATUS_ARCH_MISMATCH =8,
CUBLAS_STATUS_MAPPING_ERROR =11,
CUBLAS_STATUS_EXECUTION_FAILED=13,
CUBLAS_STATUS_INTERNAL_ERROR =14,
CUBLAS_STATUS_NOT_SUPPORTED =15,
CUBLAS_STATUS_LICENSE_ERROR =16
} cublasStatus_t;
typedef enum {
CUBLAS_OP_N=0,
CUBLAS_OP_T=1,
CUBLAS_OP_C=2
} cublasOperation_t;
struct cublasContext;
typedef struct cublasContext *cublasHandle_t;
typedef enum
{
CUDA_R_16F= 2, /* real as a half */
CUDA_C_16F= 6, /* complex as a pair of half numbers */
CUDA_R_32F= 0, /* real as a float */
CUDA_C_32F= 4, /* complex as a pair of float numbers */
CUDA_R_64F= 1, /* real as a double */
CUDA_C_64F= 5, /* complex as a pair of double numbers */
CUDA_R_8I = 3, /* real as a signed char */
CUDA_C_8I = 7, /* complex as a pair of signed char numbers */
CUDA_R_8U = 8, /* real as a unsigned char */
CUDA_C_8U = 9, /* complex as a pair of unsigned char numbers */
CUDA_R_32I= 10, /* real as a signed int */
CUDA_C_32I= 11, /* complex as a pair of signed int numbers */
CUDA_R_32U= 12, /* real as a unsigned int */
CUDA_C_32U= 13 /* complex as a pair of unsigned int numbers */
} cublasDataType_t;
typedef void (*CblasSgemv)(CBLAS_ORDER Layout,
CBLAS_TRANSPOSE TransA, int M, int N,
float alpha, float *A, int lda,
float *X, int incX, float beta,
float *Y, int incY);
typedef void (*CblasDgemv)(CBLAS_ORDER Layout,
CBLAS_TRANSPOSE TransA, int M, int N,
double alpha, double *A, int lda,
double *X, int incX, double beta,
double *Y, int incY);
typedef void (*CblasSgemm)(CBLAS_ORDER Layout, CBLAS_TRANSPOSE TransA,
CBLAS_TRANSPOSE TransB, int M, int N,
int K, float alpha, float *A,
int lda, float *B, int ldb,
float beta, float *C, int ldc);
typedef void (*CblasDgemm)(CBLAS_ORDER Layout, CBLAS_TRANSPOSE TransA,
CBLAS_TRANSPOSE TransB, int M, int N,
int K, double alpha, double *A,
int lda, double *B, int ldb,
double beta, double *C, int ldc);
typedef void (*CblasSgemmBatch)(CBLAS_ORDER Layout, CBLAS_TRANSPOSE *TransA_Array,
CBLAS_TRANSPOSE *TransB_Array, int *M_Array, int *N_Array,
int *K_Array, float *alpha_Array, float **A_Array,
int *lda_Array, float **B_Array, int *ldb_Array,
float *beta_Array, float **C_Array, int *ldc_Array,
int group_count, int *group_size);
typedef void (*CblasDgemmBatch)(CBLAS_ORDER Layout, CBLAS_TRANSPOSE *TransA_Array,
CBLAS_TRANSPOSE *TransB_Array, int *M_Array, int *N_Array,
int *K_Array, double *alpha_Array, double **A_Array,
int *lda_Array, double **B_Array, int* ldb_Array,
double *beta_Array, double **C_Array, int *ldc_Array,
int group_count, int *group_size);
#ifdef LAPACK_ROW_MAJOR
#undef LAPACK_ROW_MAJOR
#endif
#ifdef LAPACK_COL_MAJOR
#undef LAPACK_COL_MAJOR
#endif
enum LAPACK_LAYOUT { LAPACK_ROW_MAJOR=101, LAPACK_COL_MAJOR=102 };
typedef int (*LapackeSgesvd)(LAPACK_LAYOUT matrix_layout, char jobu, char jobvt,
int m, int n, float* a, int lda,
float* s, float* u, int ldu, float* vt,
int ldvt, float* superb);
typedef int (*LapackeDgesvd)(LAPACK_LAYOUT matrix_layout, char jobu, char jobvt,
int m, int n, double* a,
int lda, double* s, double* u, int ldu,
double* vt, int ldvt, double* superb);
typedef int (*LapackeSgesdd)(LAPACK_LAYOUT matrix_layout, char jobz, int m,
int n, float* a, int lda, float* s,
float* u, int ldu, float* vt,
int ldvt);
typedef int (*LapackeDgesdd)(LAPACK_LAYOUT matrix_layout, char jobz, int m,
int n, double* a, int lda, double* s,
double* u, int ldu, double* vt,
int ldvt);
typedef cublasStatus_t (CUBLASWINAPI *CublasSgemv)(cublasHandle_t handle,
cublasOperation_t trans,
int m,
int n,
float *alpha, /* host or device pointer */
float *A,
int lda,
float *x,
int incx,
float *beta, /* host or device pointer */
float *y,
int incy);
typedef cublasStatus_t (CUBLASWINAPI *CublasDgemv)(cublasHandle_t handle,
cublasOperation_t trans,
int m,
int n,
double *alpha, /* host or device pointer */
double *A,
int lda,
double *x,
int incx,
double *beta, /* host or device pointer */
double *y,
int incy);
typedef cublasStatus_t (CUBLASWINAPI *CublasHgemm)(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int m,
int n,
int k,
__half *alpha, /* host or device pointer */
__half *A,
int lda,
__half *B,
int ldb,
__half *beta, /* host or device pointer */
__half *C,
int ldc);
typedef cublasStatus_t (CUBLASWINAPI *CublasSgemm)(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int m,
int n,
int k,
float *alpha, /* host or device pointer */
float *A,
int lda,
float *B,
int ldb,
float *beta, /* host or device pointer */
float *C,
int ldc);
typedef cublasStatus_t (CUBLASWINAPI *CublasDgemm)(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int m,
int n,
int k,
double *alpha, /* host or device pointer */
double *A,
int lda,
double *B,
int ldb,
double *beta, /* host or device pointer */
double *C,
int ldc);
typedef cublasStatus_t (CUBLASWINAPI *CublasSgemmEx)(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int m,
int n,
int k,
float *alpha, /* host or device pointer */
void *A,
cublasDataType_t Atype,
int lda,
void *B,
cublasDataType_t Btype,
int ldb,
float *beta, /* host or device pointer */
void *C,
cublasDataType_t Ctype,
int ldc);
typedef cublasStatus_t (CUBLASWINAPI *CublasHgemmBatched)(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int m,
int n,
int k,
__half *alpha, /* host or device pointer */
__half *Aarray[],
int lda,
__half *Barray[],
int ldb,
__half *beta, /* host or device pointer */
__half *Carray[],
int ldc,
int batchCount);
typedef cublasStatus_t (CUBLASWINAPI *CublasSgemmBatched)(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int m,
int n,
int k,
float *alpha, /* host or device pointer */
float *Aarray[],
int lda,
float *Barray[],
int ldb,
float *beta, /* host or device pointer */
float *Carray[],
int ldc,
int batchCount);
typedef cublasStatus_t (CUBLASWINAPI *CublasDgemmBatched)(cublasHandle_t handle,
cublasOperation_t transa,
cublasOperation_t transb,
int m,
int n,
int k,
double *alpha, /* host or device pointer */
double *Aarray[],
int lda,
double *Barray[],
int ldb,
double *beta, /* host or device pointer */
double *Carray[],
int ldc,
int batchCount);
typedef enum{
CUSOLVER_STATUS_SUCCESS=0,
CUSOLVER_STATUS_NOT_INITIALIZED=1,
CUSOLVER_STATUS_ALLOC_FAILED=2,
CUSOLVER_STATUS_INVALID_VALUE=3,
CUSOLVER_STATUS_ARCH_MISMATCH=4,
CUSOLVER_STATUS_MAPPING_ERROR=5,
CUSOLVER_STATUS_EXECUTION_FAILED=6,
CUSOLVER_STATUS_INTERNAL_ERROR=7,
CUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED=8,
CUSOLVER_STATUS_NOT_SUPPORTED = 9,
CUSOLVER_STATUS_ZERO_PIVOT=10,
CUSOLVER_STATUS_INVALID_LICENSE=11
} cusolverStatus_t;
typedef enum {
CUSOLVER_EIG_TYPE_1=1,
CUSOLVER_EIG_TYPE_2=2,
CUSOLVER_EIG_TYPE_3=3
} cusolverEigType_t ;
typedef enum {
CUSOLVER_EIG_MODE_NOVECTOR=0,
CUSOLVER_EIG_MODE_VECTOR=1
} cusolverEigMode_t ;
struct cusolverDnContext;
typedef struct cusolverDnContext *cusolverDnHandle_t;
typedef cusolverStatus_t (CUSOLVERAPI *CusolverDnSgesvdBufferSize)(
cusolverDnHandle_t handle,
int m,
int n,
int *lwork);
typedef cusolverStatus_t (CUSOLVERAPI *CusolverDnDgesvdBufferSize)(
cusolverDnHandle_t handle,
int m,
int n,
int *lwork);
typedef cusolverStatus_t (CUSOLVERAPI *CusolverDnSgesvd)(
cusolverDnHandle_t handle,
signed char jobu,
signed char jobvt,
int m,
int n,
float *A,
int lda,
float *S,
float *U,
int ldu,
float *VT,
int ldvt,
float *work,
int lwork,
float *rwork,
int *info);
typedef cusolverStatus_t (CUSOLVERAPI *CusolverDnDgesvd)(
cusolverDnHandle_t handle,
signed char jobu,
signed char jobvt,
int m,
int n,
double *A,
int lda,
double *S,
double *U,
int ldu,
double *VT,
int ldvt,
double *work,
int lwork,
double *rwork,
int *info);
enum BlasFunctions {
GEMV = 0,
GEMM = 1,
};
class BlasHelper {
private:
bool _hasHgemv = false;
bool _hasHgemm = false;
bool _hasHgemmBatch = false;
bool _hasSgemv = false;
bool _hasSgemm = false;
bool _hasSgemmBatch = false;
bool _hasDgemv = false;
bool _hasDgemm = false;
bool _hasDgemmBatch = false;
CblasSgemv cblasSgemv;
CblasDgemv cblasDgemv;
CblasSgemm cblasSgemm;
CblasDgemm cblasDgemm;
CblasSgemmBatch cblasSgemmBatch;
CblasDgemmBatch cblasDgemmBatch;
LapackeSgesvd lapackeSgesvd;
LapackeDgesvd lapackeDgesvd;
LapackeSgesdd lapackeSgesdd;
LapackeDgesdd lapackeDgesdd;
CublasSgemv cublasSgemv;
CublasDgemv cublasDgemv;
CublasHgemm cublasHgemm;
CublasSgemm cublasSgemm;
CublasDgemm cublasDgemm;
CublasSgemmEx cublasSgemmEx;
CublasHgemmBatched cublasHgemmBatched;
CublasSgemmBatched cublasSgemmBatched;
CublasDgemmBatched cublasDgemmBatched;
CusolverDnSgesvdBufferSize cusolverDnSgesvdBufferSize;
CusolverDnDgesvdBufferSize cusolverDnDgesvdBufferSize;
CusolverDnSgesvd cusolverDnSgesvd;
CusolverDnDgesvd cusolverDnDgesvd;
public:
static BlasHelper& getInstance();
void initializeFunctions(Nd4jPointer *functions);
void initializeDeviceFunctions(Nd4jPointer *functions);
template <typename T>
bool hasGEMV();
template <typename T>
bool hasGEMM();
bool hasGEMM(const sd::DataType dtype);
bool hasGEMV(const sd::DataType dtype);
template <typename T>
bool hasBatchedGEMM();
CblasSgemv sgemv();
CblasDgemv dgemv();
CblasSgemm sgemm();
CblasDgemm dgemm();
CblasSgemmBatch sgemmBatched();
CblasDgemmBatch dgemmBatched();
LapackeSgesvd sgesvd();
LapackeDgesvd dgesvd();
LapackeSgesdd sgesdd();
LapackeDgesdd dgesdd();
// destructor
~BlasHelper() noexcept;
};
}
#endif
|
Square <- function(x) {
return(x^2)
}
cat("R program running")
print(Square(4))
while (TRUE) {
Sys.sleep(3)
}
|
%--------------------------------------------------------------------------------
% File Name : subnotes/intro.tex
% Created By : rikutakei
% Creation Date : [2017-04-03 10:27]
% Last Modified : [2017-04-03 20:15]
% Description : Intro for my notebook
%--------------------------------------------------------------------------------
\chapter*{Preface}
\label{cha:preface}
This notebook is for noting down all of the concepts and background information I need to know for my current and future projects.
I will try and maintain all of the references and keep this note as updated as possible.
\\
\noindent
This notebook is free of use for everyone, as long as it complies with the licence file associated with this Git repository.
\vfill
Riku Takei
|
module Control.Permutation.Proofs
import Control.Permutation.Mod
%access export
%default total
||| Proof that (n + 1)! >= n!
private
factorialIncr : (n : Nat) -> LTE (factorial n) (factorial (S n))
factorialIncr Z = lteRefl
factorialIncr n = lteAddRight (factorial n)
||| Proof that n! >= 1
export
factorialLTE : (n : Nat) -> LTE 1 (factorial n)
factorialLTE Z = lteRefl
factorialLTE (S k) = lteTransitive (factorialLTE k) (factorialIncr k)
|
module Prelude.Cast
import Builtin
import Prelude.Basics
import Prelude.Num
import Prelude.Types
%default total
-----------
-- CASTS --
-----------
-- Casts between primitives only here. They might be lossy.
||| Interface for transforming an instance of a data type to another type.
public export
interface Cast from to where
constructor MkCast
||| Perform a (potentially lossy!) cast operation.
||| @ orig The original type
cast : (orig : from) -> to
export
Cast a a where
cast = id
-- To String
export
Cast Int String where
cast = prim__cast_IntString
export
Cast Integer String where
cast = prim__cast_IntegerString
export
Cast Char String where
cast = prim__cast_CharString
export
Cast Double String where
cast = prim__cast_DoubleString
export
Cast Nat String where
cast = cast . natToInteger
export
Cast Int8 String where
cast = prim__cast_Int8String
export
Cast Int16 String where
cast = prim__cast_Int16String
export
Cast Int32 String where
cast = prim__cast_Int32String
export
Cast Int64 String where
cast = prim__cast_Int64String
export
Cast Bits8 String where
cast = prim__cast_Bits8String
export
Cast Bits16 String where
cast = prim__cast_Bits16String
export
Cast Bits32 String where
cast = prim__cast_Bits32String
export
Cast Bits64 String where
cast = prim__cast_Bits64String
-- To Integer
export
Cast Int Integer where
cast = prim__cast_IntInteger
export
Cast Char Integer where
cast = prim__cast_CharInteger
export
Cast Double Integer where
cast = prim__cast_DoubleInteger
export
Cast String Integer where
cast = prim__cast_StringInteger
export
Cast Nat Integer where
cast = natToInteger
export
Cast Bits8 Integer where
cast = prim__cast_Bits8Integer
export
Cast Bits16 Integer where
cast = prim__cast_Bits16Integer
export
Cast Bits32 Integer where
cast = prim__cast_Bits32Integer
export
Cast Bits64 Integer where
cast = prim__cast_Bits64Integer
export
Cast Int8 Integer where
cast = prim__cast_Int8Integer
export
Cast Int16 Integer where
cast = prim__cast_Int16Integer
export
Cast Int32 Integer where
cast = prim__cast_Int32Integer
export
Cast Int64 Integer where
cast = prim__cast_Int64Integer
-- To Int
export
Cast Integer Int where
cast = prim__cast_IntegerInt
export
Cast Char Int where
cast = prim__cast_CharInt
export
Cast Double Int where
cast = prim__cast_DoubleInt
export
Cast String Int where
cast = prim__cast_StringInt
export
Cast Nat Int where
cast = fromInteger . natToInteger
export
Cast Bits8 Int where
cast = prim__cast_Bits8Int
export
Cast Bits16 Int where
cast = prim__cast_Bits16Int
export
Cast Bits32 Int where
cast = prim__cast_Bits32Int
export
Cast Bits64 Int where
cast = prim__cast_Bits64Int
export
Cast Int8 Int where
cast = prim__cast_Int8Int
export
Cast Int16 Int where
cast = prim__cast_Int16Int
export
Cast Int32 Int where
cast = prim__cast_Int32Int
export
Cast Int64 Int where
cast = prim__cast_Int64Int
-- To Char
export
Cast Int Char where
cast = prim__cast_IntChar
export
Cast Integer Char where
cast = prim__cast_IntegerChar
export
Cast Nat Char where
cast = cast . natToInteger
export
Cast Bits8 Char where
cast = prim__cast_Bits8Char
export
Cast Bits16 Char where
cast = prim__cast_Bits16Char
export
Cast Bits32 Char where
cast = prim__cast_Bits32Char
export
Cast Bits64 Char where
cast = prim__cast_Bits64Char
export
Cast Int8 Char where
cast = prim__cast_Int8Char
export
Cast Int16 Char where
cast = prim__cast_Int16Char
export
Cast Int32 Char where
cast = prim__cast_Int32Char
export
Cast Int64 Char where
cast = prim__cast_Int64Char
-- To Double
export
Cast Int Double where
cast = prim__cast_IntDouble
export
Cast Integer Double where
cast = prim__cast_IntegerDouble
export
Cast String Double where
cast = prim__cast_StringDouble
export
Cast Nat Double where
cast = prim__cast_IntegerDouble . natToInteger
export
Cast Bits8 Double where
cast = prim__cast_Bits8Double
export
Cast Bits16 Double where
cast = prim__cast_Bits16Double
export
Cast Bits32 Double where
cast = prim__cast_Bits32Double
export
Cast Bits64 Double where
cast = prim__cast_Bits64Double
export
Cast Int8 Double where
cast = prim__cast_Int8Double
export
Cast Int16 Double where
cast = prim__cast_Int16Double
export
Cast Int32 Double where
cast = prim__cast_Int32Double
export
Cast Int64 Double where
cast = prim__cast_Int64Double
-- To Bits8
export
Cast Int Bits8 where
cast = prim__cast_IntBits8
export
Cast Integer Bits8 where
cast = prim__cast_IntegerBits8
export
Cast Bits16 Bits8 where
cast = prim__cast_Bits16Bits8
export
Cast Bits32 Bits8 where
cast = prim__cast_Bits32Bits8
export
Cast Bits64 Bits8 where
cast = prim__cast_Bits64Bits8
export
Cast String Bits8 where
cast = prim__cast_StringBits8
export
Cast Double Bits8 where
cast = prim__cast_DoubleBits8
export
Cast Char Bits8 where
cast = prim__cast_CharBits8
export
Cast Nat Bits8 where
cast = cast . natToInteger
export
Cast Int8 Bits8 where
cast = prim__cast_Int8Bits8
export
Cast Int16 Bits8 where
cast = prim__cast_Int16Bits8
export
Cast Int32 Bits8 where
cast = prim__cast_Int32Bits8
export
Cast Int64 Bits8 where
cast = prim__cast_Int64Bits8
-- To Bits16
export
Cast Int Bits16 where
cast = prim__cast_IntBits16
export
Cast Integer Bits16 where
cast = prim__cast_IntegerBits16
export
Cast Bits8 Bits16 where
cast = prim__cast_Bits8Bits16
export
Cast Bits32 Bits16 where
cast = prim__cast_Bits32Bits16
export
Cast Bits64 Bits16 where
cast = prim__cast_Bits64Bits16
export
Cast String Bits16 where
cast = prim__cast_StringBits16
export
Cast Double Bits16 where
cast = prim__cast_DoubleBits16
export
Cast Char Bits16 where
cast = prim__cast_CharBits16
export
Cast Nat Bits16 where
cast = cast . natToInteger
export
Cast Int8 Bits16 where
cast = prim__cast_Int8Bits16
export
Cast Int16 Bits16 where
cast = prim__cast_Int16Bits16
export
Cast Int32 Bits16 where
cast = prim__cast_Int32Bits16
export
Cast Int64 Bits16 where
cast = prim__cast_Int64Bits16
-- To Bits32
export
Cast Int Bits32 where
cast = prim__cast_IntBits32
export
Cast Integer Bits32 where
cast = prim__cast_IntegerBits32
export
Cast Bits8 Bits32 where
cast = prim__cast_Bits8Bits32
export
Cast Bits16 Bits32 where
cast = prim__cast_Bits16Bits32
export
Cast Bits64 Bits32 where
cast = prim__cast_Bits64Bits32
export
Cast String Bits32 where
cast = prim__cast_StringBits32
export
Cast Double Bits32 where
cast = prim__cast_DoubleBits32
export
Cast Char Bits32 where
cast = prim__cast_CharBits32
export
Cast Nat Bits32 where
cast = cast . natToInteger
export
Cast Int8 Bits32 where
cast = prim__cast_Int8Bits32
export
Cast Int16 Bits32 where
cast = prim__cast_Int16Bits32
export
Cast Int32 Bits32 where
cast = prim__cast_Int32Bits32
export
Cast Int64 Bits32 where
cast = prim__cast_Int64Bits32
-- To Bits64
export
Cast Int Bits64 where
cast = prim__cast_IntBits64
export
Cast Integer Bits64 where
cast = prim__cast_IntegerBits64
export
Cast Bits8 Bits64 where
cast = prim__cast_Bits8Bits64
export
Cast Bits16 Bits64 where
cast = prim__cast_Bits16Bits64
export
Cast Bits32 Bits64 where
cast = prim__cast_Bits32Bits64
export
Cast String Bits64 where
cast = prim__cast_StringBits64
export
Cast Double Bits64 where
cast = prim__cast_DoubleBits64
export
Cast Char Bits64 where
cast = prim__cast_CharBits64
export
Cast Nat Bits64 where
cast = cast . natToInteger
export
Cast Int8 Bits64 where
cast = prim__cast_Int8Bits64
export
Cast Int16 Bits64 where
cast = prim__cast_Int16Bits64
export
Cast Int32 Bits64 where
cast = prim__cast_Int32Bits64
export
Cast Int64 Bits64 where
cast = prim__cast_Int64Bits64
-- To Int8
export
Cast String Int8 where
cast = prim__cast_StringInt8
export
Cast Double Int8 where
cast = prim__cast_DoubleInt8
export
Cast Char Int8 where
cast = prim__cast_CharInt8
export
Cast Int Int8 where
cast = prim__cast_IntInt8
export
Cast Integer Int8 where
cast = prim__cast_IntegerInt8
export
Cast Nat Int8 where
cast = cast . natToInteger
export
Cast Bits8 Int8 where
cast = prim__cast_Bits8Int8
export
Cast Bits16 Int8 where
cast = prim__cast_Bits16Int8
export
Cast Bits32 Int8 where
cast = prim__cast_Bits32Int8
export
Cast Bits64 Int8 where
cast = prim__cast_Bits64Int8
export
Cast Int16 Int8 where
cast = prim__cast_Int16Int8
export
Cast Int32 Int8 where
cast = prim__cast_Int32Int8
export
Cast Int64 Int8 where
cast = prim__cast_Int64Int8
-- To Int16
export
Cast String Int16 where
cast = prim__cast_StringInt16
export
Cast Double Int16 where
cast = prim__cast_DoubleInt16
export
Cast Char Int16 where
cast = prim__cast_CharInt16
export
Cast Int Int16 where
cast = prim__cast_IntInt16
export
Cast Integer Int16 where
cast = prim__cast_IntegerInt16
export
Cast Nat Int16 where
cast = cast . natToInteger
export
Cast Bits8 Int16 where
cast = prim__cast_Bits8Int16
export
Cast Bits16 Int16 where
cast = prim__cast_Bits16Int16
export
Cast Bits32 Int16 where
cast = prim__cast_Bits32Int16
export
Cast Bits64 Int16 where
cast = prim__cast_Bits64Int16
export
Cast Int8 Int16 where
cast = prim__cast_Int8Int16
export
Cast Int32 Int16 where
cast = prim__cast_Int32Int16
export
Cast Int64 Int16 where
cast = prim__cast_Int64Int16
-- To Int32
export
Cast String Int32 where
cast = prim__cast_StringInt32
export
Cast Double Int32 where
cast = prim__cast_DoubleInt32
export
Cast Char Int32 where
cast = prim__cast_CharInt32
export
Cast Int Int32 where
cast = prim__cast_IntInt32
export
Cast Integer Int32 where
cast = prim__cast_IntegerInt32
export
Cast Nat Int32 where
cast = cast . natToInteger
export
Cast Bits8 Int32 where
cast = prim__cast_Bits8Int32
export
Cast Bits16 Int32 where
cast = prim__cast_Bits16Int32
export
Cast Bits32 Int32 where
cast = prim__cast_Bits32Int32
export
Cast Bits64 Int32 where
cast = prim__cast_Bits64Int32
export
Cast Int8 Int32 where
cast = prim__cast_Int8Int32
export
Cast Int16 Int32 where
cast = prim__cast_Int16Int32
export
Cast Int64 Int32 where
cast = prim__cast_Int64Int32
-- To Int64
export
Cast String Int64 where
cast = prim__cast_StringInt64
export
Cast Double Int64 where
cast = prim__cast_DoubleInt64
export
Cast Char Int64 where
cast = prim__cast_CharInt64
export
Cast Int Int64 where
cast = prim__cast_IntInt64
export
Cast Integer Int64 where
cast = prim__cast_IntegerInt64
export
Cast Nat Int64 where
cast = cast . natToInteger
export
Cast Bits8 Int64 where
cast = prim__cast_Bits8Int64
export
Cast Bits16 Int64 where
cast = prim__cast_Bits16Int64
export
Cast Bits32 Int64 where
cast = prim__cast_Bits32Int64
export
Cast Bits64 Int64 where
cast = prim__cast_Bits64Int64
export
Cast Int8 Int64 where
cast = prim__cast_Int8Int64
export
Cast Int16 Int64 where
cast = prim__cast_Int16Int64
export
Cast Int32 Int64 where
cast = prim__cast_Int32Int64
-- To Nat
export
Cast String Nat where
cast = integerToNat . cast
export
Cast Double Nat where
cast = integerToNat . cast
export
Cast Char Nat where
cast = integerToNat . cast {to = Integer}
export
Cast Int Nat where
cast = integerToNat . cast
export
Cast Integer Nat where
cast = integerToNat
export
Cast Bits8 Nat where
cast = integerToNat . cast {to = Integer}
export
Cast Bits16 Nat where
cast = integerToNat . cast {to = Integer}
export
Cast Bits32 Nat where
cast = integerToNat . cast {to = Integer}
export
Cast Bits64 Nat where
cast = integerToNat . cast {to = Integer}
export
Cast Int8 Nat where
cast = integerToNat . cast
export
Cast Int16 Nat where
cast = integerToNat . cast
export
Cast Int32 Nat where
cast = integerToNat . cast
export
Cast Int64 Nat where
cast = integerToNat . cast
|
module Control.MonadRec
import public Control.WellFounded
import Control.Monad.Either
import Control.Monad.Identity
import Control.Monad.Maybe
import Control.Monad.Reader
import Control.Monad.RWS
import Control.Monad.State
import Control.Monad.Writer
import Data.List
import Data.SnocList
import public Data.Fuel
import public Data.Nat
%default total
--------------------------------------------------------------------------------
-- Sized Implementations
--------------------------------------------------------------------------------
public export
Sized Fuel where
size Dry = 0
size (More f) = S $ size f
public export
Sized (SnocList a) where
size = length
--------------------------------------------------------------------------------
-- Step
--------------------------------------------------------------------------------
||| Single step in a recursive computation.
|||
||| A `Step` is either `Done`, in which case we return the
||| final result, or `Cont`, in which case we continue
||| iterating. In case of a `Cont`, we get a new seed for
||| the next iteration plus an updated state. In addition
||| we proof that the sequence of seeds is related via `rel`.
||| If `rel` is well-founded, the recursion will provably
||| come to an end in a finite number of steps.
public export
data Step : (rel : a -> a -> Type)
-> (seed : a)
-> (accum : Type)
-> (res : Type)
-> Type where
||| Keep iterating with a new `seed2`, which is
||| related to the current `seed` via `rel`.
||| `vst` is the accumulated state of the iteration.
Cont : (seed2 : a)
-> (0 prf : rel seed2 seed)
-> (vst : st)
-> Step rel seed st res
||| Stop iterating and return the given result.
Done : (vres : res) -> Step rel v st res
public export
Bifunctor (Step rel seed) where
bimap f _ (Cont s2 prf st) = Cont s2 prf (f st)
bimap _ g (Done res) = Done (g res)
mapFst f (Cont s2 prf st) = Cont s2 prf (f st)
mapFst _ (Done res) = Done res
mapSnd _ (Cont s2 prf st) = Cont s2 prf st
mapSnd g (Done res) = Done (g res)
--------------------------------------------------------------------------------
-- MonadRec
--------------------------------------------------------------------------------
||| Interface for tail-call optimized monadic recursion.
public export
interface Monad m => MonadRec m where
||| Implementers mus make sure they implement this function
||| in a tail recursive manner.
||| The general idea is to loop using the given `step` function
||| until it returns a `Done`.
|||
||| To convey to the totality checker that the sequence
||| of seeds generated during recursion must come to an
||| end after a finite number of steps, this function
||| requires an erased proof of accessibility.
total
tailRecM : {0 rel : a -> a -> Type}
-> (seed : a)
-> (ini : st)
-> (0 prf : Accessible rel seed)
-> (step : (seed2 : a) -> st -> m (Step rel seed2 st b))
-> m b
public export %inline
||| Monadic tail recursion over a sized structure.
trSized : MonadRec m
=> (0 _ : Sized a)
=> (seed : a)
-> (ini : st)
-> (step : (v : a) -> st -> m (Step Smaller v st b))
-> m b
trSized x ini = tailRecM x ini (sizeAccessible x)
--------------------------------------------------------------------------------
-- Base Implementations
--------------------------------------------------------------------------------
public export
MonadRec Identity where
tailRecM seed st1 (Access rec) f = case f seed st1 of
Id (Done b) => Id b
Id (Cont y prf st2) => tailRecM y st2 (rec y prf) f
public export
MonadRec Maybe where
tailRecM seed st1 (Access rec) f = case f seed st1 of
Nothing => Nothing
Just (Done b) => Just b
Just (Cont y prf st2) => tailRecM y st2 (rec y prf) f
public export
MonadRec (Either e) where
tailRecM seed st1 (Access rec) f = case f seed st1 of
Left e => Left e
Right (Done b) => Right b
Right (Cont y prf st2) => tailRecM y st2 (rec y prf) f
trIO : (x : a)
-> (ini : st)
-> (0 _ : Accessible rel x)
-> (f : (v : a) -> st -> IO (Step rel v st b))
-> IO b
trIO x ini acc f = fromPrim $ run x ini acc
where run : (y : a) -> (st1 : st)
-> (0 _ : Accessible rel y)
-> (1 w : %World)
-> IORes b
run y st1 (Access rec) w = case toPrim (f y st1) w of
MkIORes (Done b) w2 => MkIORes b w2
MkIORes (Cont y2 prf st2) w2 => run y2 st2 (rec y2 prf) w2
public export %inline
MonadRec IO where
tailRecM = trIO
--------------------------------------------------------------------------------
-- Transformer Implementations
--------------------------------------------------------------------------------
---------------------------
-- StateT
%inline
convST : Functor m
=> (f : (v : a) -> st -> StateT s m (Step rel v st b))
-> (v : a)
-> (st,s)
-> m (Step rel v (st,s) (s,b))
convST f v (st1,s1) = (\(s2,stp) => bimap (,s2) (s2,) stp)
<$> runStateT s1 (f v st1)
public export
MonadRec m => MonadRec (StateT s m) where
tailRecM x ini acc f =
ST $ \s1 => tailRecM x (ini,s1) acc (convST f)
---------------------------
-- EitherT
convE : Functor m
=> (f : (v : a) -> st -> EitherT e m (Step rel v st b))
-> (v : a)
-> (ini : st)
-> m (Step rel v st (Either e b))
convE f v s1 = map conv $ runEitherT (f v s1)
where conv : Either e (Step rel v st b) -> Step rel v st (Either e b)
conv (Left err) = Done (Left err)
conv (Right $ Done b) = Done (Right b)
conv (Right $ Cont v2 prf st2) = Cont v2 prf st2
public export
MonadRec m => MonadRec (EitherT e m) where
tailRecM x ini acc f =
MkEitherT $ tailRecM x ini acc (convE f)
---------------------------
-- MaybeT
convM : Functor m
=> (f : (v : a) -> st -> MaybeT m (Step rel v st b))
-> (v : a)
-> (ini : st)
-> m (Step rel v st (Maybe b))
convM f v s1 = map conv $ runMaybeT (f v s1)
where conv : Maybe (Step rel v st b) -> Step rel v st (Maybe b)
conv Nothing = Done Nothing
conv (Just $ Done b) = Done (Just b)
conv (Just $ Cont v2 prf st2) = Cont v2 prf st2
public export
MonadRec m => MonadRec (MaybeT m) where
tailRecM x ini acc f =
MkMaybeT $ tailRecM x ini acc (convM f)
---------------------------
-- ReaderT
convR : (f : (v : a) -> st -> ReaderT e m (Step rel v st b))
-> (env : e)
-> (v : a)
-> (ini : st)
-> m (Step rel v st b)
convR f env v s1 = runReaderT env (f v s1)
public export
MonadRec m => MonadRec (ReaderT e m) where
tailRecM x ini acc f =
MkReaderT $ \env => tailRecM x ini acc (convR f env)
---------------------------
-- WriterT
convW : Functor m
=> (f : (v : a) -> st -> WriterT w m (Step rel v st b))
-> (v : a)
-> (st,w)
-> m (Step rel v (st,w) (b,w))
convW f v (s1,w1) = (\(stp,w2) => bimap (,w2) (,w2) stp)
<$> unWriterT (f v s1) w1
public export
MonadRec m => MonadRec (WriterT w m) where
tailRecM x ini acc f =
MkWriterT $ \w1 => tailRecM x (ini,w1) acc (convW f)
---------------------------
-- RWST
convRWS : Functor m
=> (f : (v : a) -> st -> RWST r w s m (Step rel v st b))
-> (env : r)
-> (v : a)
-> (st,s,w)
-> m (Step rel v (st,s,w) (b,s,w))
convRWS f env v (st1,s1,w1) = (\(stp,s2,w2) => bimap (,s2,w2) (,s2,w2) stp)
<$> unRWST (f v st1) env s1 w1
public export
MonadRec m => MonadRec (RWST r w s m) where
tailRecM x ini acc f =
MkRWST $ \r1,s1,w1 => tailRecM x (ini,s1,w1) acc (convRWS f r1)
|
Formal statement is: lemma AE_ball_countable: assumes [intro]: "countable X" shows "(AE x in M. \<forall>y\<in>X. P x y) \<longleftrightarrow> (\<forall>y\<in>X. AE x in M. P x y)" Informal statement is: If $X$ is countable, then the almost everywhere statement $\forall y \in X. P(x, y)$ is equivalent to the statement $\forall y \in X. \text{almost everywhere } P(x, y)$. |
#!/usr/bin/env python
# coding: utf-8
# ## Observations and Insights
# * The tumor volume for mice who were administered Capomulin had lower standard deviation and variance acorss more times being administered
# * Capomulin and Ramicane both have similar sample data as do Infubinol and Ceftamin. More research can be done on the similarities of these 2 groups of drugs to see how they so similarly affected the Tumor Volume of the Mice.
# * In looking at the scatter plot, there looks to be a positive correlation between mouse weight and the average tumor volume. Furthermore, the liner regression displayed can be a good representation to predict futre samples.
# ---
# In[1]:
# Dependencies and Setup
import matplotlib.pyplot as plt
import pandas as pd
import scipy.stats as st
# Study data files
mouse_metadata_path = "data/Mouse_metadata.csv"
study_results_path = "data/Study_results.csv"
# Read the mouse data and the study results
mouse_metadata = pd.read_csv(mouse_metadata_path)
study_results = pd.read_csv(study_results_path)
# Combine the data into a single dataset
merge_df = pd.merge(study_results,mouse_metadata, on="Mouse ID")
# Display the data table for preview
merge_df.head()
# In[2]:
# Check the number of mice.
len(merge_df["Mouse ID"].unique())
# In[3]:
# Getting the duplicate mice by ID number that shows up for Mouse ID and Timepoint.
duplicated_id = merge_df.loc[merge_df.duplicated(subset = ['Mouse ID', 'Timepoint']), 'Mouse ID'].unique()
duplicated_id
# In[4]:
# Optional: Get all the data for the duplicate mouse ID.
merge_df.loc[merge_df['Mouse ID'] == 'g989', :]
# In[5]:
# Create a clean DataFrame by dropping the duplicate mouse by its ID.
cleaned_df = merge_df.loc[merge_df['Mouse ID'].isin(duplicated_id) == False]
# In[6]:
# Check the number of mice in the clean DataFrame.
non_dupl = len(cleaned_df["Mouse ID"].unique())
non_dupl
# ## Summary Statistics
# In[7]:
# Generate a summary statistics table of mean, median, variance, standard deviation, and SEM of the tumor volume for each regimen
# Use this straighforward method, create multiple series and put them all in a dataframe at the end.
drug_group1 = cleaned_df.groupby(['Drug Regimen'])
drug_df1 = pd.DataFrame({'Mean Tumor Volume' : drug_group1['Tumor Volume (mm3)'].mean(),
'Median Tumor Volume' : drug_group1['Tumor Volume (mm3)'].median(),
'Tumor Volume Variance' : drug_group1['Tumor Volume (mm3)'].var(),
'Tumor Volume Std. Dev.' : drug_group1['Tumor Volume (mm3)'].std(),
'Tumor Volume Std. Err.' : drug_group1['Tumor Volume (mm3)'].sem()})
drug_df1
# In[8]:
# Generate a summary statistics table of mean, median, variance, standard deviation, and SEM of the tumor volume for each regimen
# Use method to produce everything with a single groupby function
drug_group2 = cleaned_df.groupby(['Drug Regimen']).agg({'Tumor Volume (mm3)' : ['mean', 'median', 'var', 'std', 'sem']})
drug_group2
# ## Bar and Pie Charts
# In[9]:
# Generate a bar plot showing the total number of mice for each treatment throughout the course of the study using pandas.
drug_count = cleaned_df['Drug Regimen'].value_counts()
drug_chart = drug_count.plot(kind='bar')
# drug_chart.set_xlabel("Drug Regimen")
drug_chart.set_xlabel("Drug Regimen")
drug_chart.set_ylabel("Number of Data Points")
plt.show()
# In[10]:
drug_count
# In[11]:
# Generate a bar plot showing the total number of mice for each treatment throughout the course of the study using pyplot.
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
drugs = ['Capomulin', 'Ramicane', 'Ketapril', 'Naftisol', 'Zoniferol', 'Placebo',
'Stelasyn','Infubinol', 'Ceftamin', 'Propriva']
counts = [230, 228, 188, 186, 182, 181, 181, 178, 178, 148]
plt.xlabel("Drug Regimen")
plt.ylabel("Number of Data Points")
plt.xticks(rotation=90)
ax.bar(drugs,counts)
plt.show()
# In[14]:
sex_count
# In[15]:
# Generate a pie plot showing the distribution of female versus male mice using pandas
sex_count = cleaned_df['Sex'].value_counts()
sex_chart = sex_count.plot(kind='pie',autopct="%1.1f%%")
sex_chart.set_ylabel("Sex")
plt.show()
# In[16]:
# Generate a pie plot showing the distribution of female versus male mice using pyplot
sex = 'Male', 'Female'
sex_count = cleaned_df['Sex'].value_counts()
plt.pie(sex_count,labels=sex, autopct='%1.1f%%')
plt.ylabel("Sex")
plt.show()
# ## Quartiles, Outliers and Boxplots
# In[17]:
# Calculate the final tumor volume of each mouse across each of the treatment regimens:
mouse_group = cleaned_df.groupby('Mouse ID')
# Start by getting the last (greatest) timepoint for each mouse
last_timepoint = mouse_group['Timepoint'].max()
mouse_df = last_timepoint.reset_index()
# max_df
# Merge this group df with the original dataframe to get the tumor volume at the last timepoint
merge_df1 = pd.merge(mouse_df, cleaned_df, how = 'left', on = ['Mouse ID', 'Timepoint'] )
merge_df1
# In[52]:
# Put 4 treatment names into a list for use with a for loop (and later for plot labels)
treatment_list = ["Capomulin", "Ramicane", "Infubinol", "Ceftamin"]
# Create a empty list to fill with tumor vol data (for plotting) (hint: each element of the list will be series)
tumor_vol_list = []
# For each treatment in the list, calculate the IQR and quantitatively determine if there are any potential outliers.
# Locate the rows which contain mice on each drug and get the tumor volumes
for drug in treatment_list:
tumor_data = merge_df1.loc[merge_df1['Drug Regimen'] == drug, 'Tumor Volume (mm3)']
tumor_vol_list.append(tumor_data)
quartiles = tumor_data.quantile([.25, .5, .75])
lowerq = quartiles[.25]
upperq = quartiles[.75]
iqr = upperq - lowerq
# add subset to tumor volume data list
# Determine outliers using upper and lower bounds
lower_bound = lowerq - (1.5 * iqr)
upper_bound = upperq + (1.5 * iqr)
outlier = tumor_data.loc[(tumor_data < lower_bound) | (tumor_data > upper_bound)]
print(f"{drug} potential outliers: {outlier}")
# In[107]:
# Generate a box plot of the final tumor volume of each mouse across four regimens of interest
fig1, ax1 = plt.subplots()
#flier adjustment
flierprops = dict(marker='o', markerfacecolor='r', markersize=12,
linestyle='none', markeredgecolor='g')
#plotting both lists used above
ax1.boxplot(tumor_vol_list, treatment_list, flierprops=flierprops)
#setting up labels
ax1.set_xticklabels(['Capomulin ', 'Ramicane ', 'Infubinol ', 'Ceftamin '])
ax1.get_xaxis().tick_bottom()
ax1.set_ylabel('Final Tumor Volume (mm3)')
plt.show()
# ## Line and Scatter Plots
# In[120]:
# Generate a line plot of time point versus tumor volume for a mouse treated with Capomulin
#need to take the full combined datafram and filter for the mouse id
capomulin_df = cleaned_df.loc[cleaned_df["Drug Regimen"] == "Capomulin"]
# capomulin_df
#locate Mouse ID 'm601'
capomulin_mouse = capomulin_df[capomulin_df["Mouse ID"] == 'm601']
capomulin_mouse = capomulin_mouse.set_index('Timepoint')
capomulin_tumor = pd.DataFrame(capomulin_mouse['Tumor Volume (mm3)'])
capomulin_tumor.plot(color = 'blue')
plt.title('Capomulin treatment of mous m601')
plt.xlabel('Timepoint (days)')
plt.ylabel('Tumor Volume (mm3)')
plt.show()
# In[121]:
# capomulin_df
# In[122]:
# capomulin_weight
# In[112]:
#Create a new groub by to combine mouse IDs and to calculate the avg for 'Tumor Volume (mm3)' & 'Weight (g)
capomulin_weight = capomulin_df.groupby('Mouse ID').mean()[['Tumor Volume (mm3)','Weight (g)']]
# Generate a scatter plot of mouse weight versus average tumor volume for the Capomulin regimen
plt.scatter(capomulin_weight['Weight (g)'],capomulin_weight['Tumor Volume (mm3)'])
plt.xlabel('Weight (g)')
plt.ylabel('Average Tumor Volume (mm3)')
plt.show()
# ## Correlation and Regression
# In[119]:
# Calculate the correlation coefficient and linear regression model
# for mouse weight and average tumor volume for the Capomulin regimen
x_values = capomulin_weight['Weight (g)']
y_values = capomulin_weight['Tumor Volume (mm3)']
correlation = st.pearsonr(x_values,y_values)
print(f"The correlation between mouse weight and the average tumor volume is {round(correlation[0],2)}")
#calculate regress values to plot linear regression line
(slope, intercept, rvalue, pvalue, stderr) = st.linregress(x_values, y_values)
regress_values = x_values * slope + intercept
# Generate a scatter plot of mouse weight versus average tumor volume and a linear regression line for the Capomulin regimen
plt.plot(x_values,regress_values,"r-")
plt.scatter(capomulin_weight['Weight (g)'],capomulin_weight['Tumor Volume (mm3)'])
plt.xlabel('Weight (g)')
plt.ylabel('Average Tumor Volume (mm3)')
plt.show()
|
{-# LANGUAGE FlexibleInstances #-}
-----------------------------------------------------------------------------
-- |
-- Module : Data.Elem.LAPACK.C
-- Copyright : Copyright (c) , Patrick Perry <[email protected]>
-- License : BSD3
-- Maintainer : Patrick Perry <[email protected]>
-- Stability : experimental
--
-- Low-level interface to LAPACK.
--
module Data.Elem.LAPACK.C
where
import Control.Exception( assert )
import Control.Monad
import Data.Complex( Complex )
import Data.Elem.BLAS.Level3
import Data.Matrix.Class( TransEnum(..), SideEnum(..) )
import Foreign
import LAPACK.CTypes
import Data.Elem.LAPACK.Double
import Data.Elem.LAPACK.Zomplex
-- | The LAPACK typeclass.
class (BLAS3 e) => LAPACK e where
geqrf :: Int -> Int -> Ptr e -> Int -> Ptr e -> IO ()
gelqf :: Int -> Int -> Ptr e -> Int -> Ptr e -> IO ()
unmqr :: SideEnum -> TransEnum -> Int -> Int -> Int -> Ptr e -> Int -> Ptr e -> Ptr e -> Int -> IO ()
unmlq :: SideEnum -> TransEnum -> Int -> Int -> Int -> Ptr e -> Int -> Ptr e -> Ptr e -> Int -> IO ()
larfg :: Int -> Ptr e -> Ptr e -> Int -> IO e
callWithWork :: (Storable e) => (Ptr e -> Int -> IO a) -> IO a
callWithWork call =
alloca $ \pQuery -> do
call pQuery (-1)
ldWork <- peek (castPtr pQuery) :: IO Double
let lWork = max 1 $ ceiling ldWork
allocaArray lWork $ \pWork -> do
call pWork lWork
checkInfo :: Int -> IO ()
checkInfo info = assert (info == 0) $ return ()
instance LAPACK Double where
geqrf m n pA ldA pTau =
checkInfo =<< callWithWork (dgeqrf m n pA ldA pTau)
gelqf m n pA ldA pTau =
checkInfo =<< callWithWork (dgelqf m n pA ldA pTau)
unmqr s t m n k pA ldA pTau pC ldC =
checkInfo =<< callWithWork (dormqr (cblasSide s) (cblasTrans t) m n k pA ldA pTau pC ldC)
unmlq s t m n k pA ldA pTau pC ldC =
checkInfo =<< callWithWork (dormlq (cblasSide s) (cblasTrans t) m n k pA ldA pTau pC ldC)
larfg n alpha x incx = with 0 $ \pTau ->
dlarfg n alpha x incx pTau >> peek pTau
instance LAPACK (Complex Double) where
geqrf m n pA ldA pTau =
checkInfo =<< callWithWork (zgeqrf m n pA ldA pTau)
gelqf m n pA ldA pTau =
checkInfo =<< callWithWork (zgelqf m n pA ldA pTau)
unmqr s t m n k pA ldA pTau pC ldC =
checkInfo =<< callWithWork (zunmqr (cblasSide s) (cblasTrans t) m n k pA ldA pTau pC ldC)
unmlq s t m n k pA ldA pTau pC ldC =
checkInfo =<< callWithWork (zunmlq (cblasSide s) (cblasTrans t) m n k pA ldA pTau pC ldC)
larfg n alpha x incx = with 0 $ \pTau ->
zlarfg n alpha x incx pTau >> peek pTau
|
theory MMU_Prg_Logic
imports
"HOL-Word.Word"
PTABLE_TLBJ.PageTable_seL4
"./../Eisbach/Rule_By_Method"
begin
type_synonym val = "32 word"
type_synonym asid = "8 word"
type_synonym word_t = "32 word"
type_synonym heap = "paddr \<rightharpoonup> word_t"
type_synonym incon_set = "vaddr set"
type_synonym global_set = "vaddr set"
datatype mode_t = Kernel | User
type_synonym vSm = "20 word"
type_synonym pSm = "20 word"
type_synonym vSe = "12 word"
type_synonym pSe = "12 word"
record tlb_flags =
nG :: "1 word" (* nG = 0 means global *)
perm_APX :: "1 word" (* Access permission bit 2 *)
perm_AP :: "2 word" (* Access permission bits 1 and 0 *)
perm_XN :: "1 word" (* Execute-never bit *)
datatype pdc_entry = PDE_Section "asid option" "12 word" (bpa_pdc_entry :"32 word") tlb_flags
| PDE_Table asid "12 word" (bpa_pdc_entry : "32 word")
datatype tlb_entry = EntrySmall (asid_of : "asid option") vSm pSm tlb_flags
| EntrySection (asid_of : "asid option") vSe pSe tlb_flags
datatype pt_walk_typ = Fault
| Partial_Walk pdc_entry
| Full_Walk tlb_entry pdc_entry
type_synonym ptable_snapshot = "asid \<Rightarrow> (vaddr set \<times> (vaddr \<Rightarrow> pt_walk_typ))"
record p_state =
heap :: heap
asid :: asid
root :: paddr
incon_set :: incon_set
global_set :: global_set
ptable_snapshot :: ptable_snapshot
mode :: mode_t
definition
load_list_word_hp :: "heap \<Rightarrow> nat \<Rightarrow> paddr \<rightharpoonup> val list"
where
"load_list_word_hp h n p = load_list h n p"
definition
from_word :: "32 word list => 'b :: len0 word"
where
"from_word \<equiv> word_rcat \<circ> rev"
definition
load_value_word_hp :: "heap \<Rightarrow> paddr \<rightharpoonup> val"
where
"load_value_word_hp h p = map_option from_word (load_list_word_hp h 1 p)"
definition
mem_read_word_heap :: "paddr \<Rightarrow> p_state \<rightharpoonup> word_t"
where
"mem_read_word_heap p s = load_value_word_hp (heap s) p "
definition
decode_heap_pde' :: "heap \<Rightarrow> paddr \<rightharpoonup> pde"
where
"decode_heap_pde' h p \<equiv> map_option decode_pde (h p)"
definition
get_pde' :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr \<rightharpoonup> pde"
where
"get_pde' h rt vp \<equiv>
let
pd_idx_offset = ((vaddr_pd_index (addr_val vp)) << 2)
in
decode_heap_pde' h (rt r+ pd_idx_offset)"
definition
decode_heap_pte' :: "heap \<Rightarrow> paddr \<rightharpoonup> pte"
where
"decode_heap_pte' h p \<equiv> map_option decode_pte (h p)"
definition
get_pte' :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr \<rightharpoonup> pte"
where
"get_pte' h pt_base vp \<equiv>
let
pt_idx_offset = ((vaddr_pt_index (addr_val vp)) << 2)
in
decode_heap_pte' h (pt_base r+ pt_idx_offset)"
definition
lookup_pte' :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr \<rightharpoonup> (paddr \<times> page_type \<times> arm_perm_bits)"
where
"lookup_pte' h pt_base vp \<equiv>
case_option None
(\<lambda>pte. case pte
of InvalidPTE \<Rightarrow> None
| SmallPagePTE base perms \<Rightarrow> Some (base, ArmSmallPage, perms))
(get_pte' h pt_base vp)"
definition
lookup_pde' :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr \<rightharpoonup> (paddr \<times> page_type \<times> arm_perm_bits)"
where
"lookup_pde' h rt vp \<equiv>
case_option None
(\<lambda>pde. case pde
of InvalidPDE \<Rightarrow> None
| ReservedPDE \<Rightarrow> None
| SectionPDE base perms \<Rightarrow> Some (base, ArmSection, perms)
| PageTablePDE pt_base \<Rightarrow> lookup_pte' h pt_base vp)
(get_pde' h rt vp)"
(* page table look-up *)
definition
ptable_lift' :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr \<rightharpoonup> paddr"
where
"ptable_lift' h pt_root vp \<equiv>
let
vp_val = addr_val vp
in
map_option
(\<lambda>(base, pg_size, perms).
base r+ (vaddr_offset pg_size vp_val))
(lookup_pde' h pt_root vp)"
definition
mem_read_hp :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr \<rightharpoonup> val"
where
"mem_read_hp hp rt vp = (ptable_lift' hp rt \<rhd>o load_value_word_hp hp) vp"
definition
ptable_trace' :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr \<Rightarrow> paddr set"
where
"ptable_trace' h rt vp \<equiv>
let
vp_val = addr_val vp ;
pd_idx_offset = ((vaddr_pd_index vp_val) << 2) ;
pt_idx_offset = ((vaddr_pt_index vp_val) << 2) ;
pd_touched = {rt r+ pd_idx_offset};
pt_touched = (\<lambda>pt_base. {pt_base r+ pt_idx_offset})
in
(case decode_pde (the (h (rt r+ pd_idx_offset)))
of PageTablePDE pt_base \<Rightarrow> pd_touched \<union> pt_touched pt_base
| _ \<Rightarrow> pd_touched)"
definition
pde_trace' :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr \<rightharpoonup> paddr"
where
"pde_trace' h rt vp \<equiv>
let
vp_val = addr_val vp ;
pd_idx_offset = ((vaddr_pd_index vp_val) << 2) ;
pd_touched = rt r+ pd_idx_offset
in
(case decode_heap_pde' h (rt r+ pd_idx_offset)
of Some pde \<Rightarrow> Some pd_touched
| None \<Rightarrow> None)"
lemma ptlift_trace_some:
"ptable_lift' h r vp = Some pa \<Longrightarrow> ptable_trace' h r vp \<noteq> {}"
by (clarsimp simp: ptable_lift'_def lookup_pde'_def get_pde'_def ptable_trace'_def Let_def
split:option.splits pde.splits)
lemma ptable_lift_preserved':
" \<lbrakk>p \<notin> ptable_trace' h r vp; ptable_lift' h r vp = Some pa\<rbrakk> \<Longrightarrow> ptable_lift' (h(p \<mapsto> v)) r vp = Some pa"
apply (frule ptlift_trace_some , clarsimp simp: ptable_lift'_def lookup_pde'_def get_pde'_def ptable_trace'_def Let_def split: option.splits)
apply (case_tac x2; clarsimp simp: decode_heap_pde'_def lookup_pte'_def split: option.splits)
apply (case_tac x2a ; clarsimp)
apply (rule conjI)
apply (rule_tac x = "(SmallPagePTE a b)" in exI, clarsimp simp: get_pte'_def decode_heap_pte'_def , clarsimp)
by (case_tac x2 ; clarsimp simp:get_pte'_def decode_heap_pte'_def)
lemma ptable_trace_get_pde:
"\<lbrakk>p \<notin> ptable_trace' h r x; get_pde' h r x = Some pde\<rbrakk> \<Longrightarrow>
get_pde' (h(p \<mapsto> v)) r x = Some pde"
apply (clarsimp simp: ptable_trace'_def Let_def get_pde'_def decode_heap_pde'_def )
by (case_tac " decode_pde z" ; clarsimp)
lemma ptable_trace_preserved':
"\<lbrakk>ptable_lift' h r vp = Some pb; p \<notin> ptable_trace' h r vp;
pa \<notin> ptable_trace' h r vp \<rbrakk> \<Longrightarrow> pa \<notin> ptable_trace' (h(p \<mapsto> v)) r vp"
apply (frule ptlift_trace_some)
apply (subgoal_tac "ptable_trace' (h(p \<mapsto> v)) r vp \<noteq> {}")
prefer 2
apply (clarsimp simp: ptable_lift'_def lookup_pde'_def get_pde'_def ptable_trace'_def Let_def split: option.splits)
apply (case_tac x2 ; clarsimp simp: decode_heap_pde'_def)
by (clarsimp simp: ptable_lift'_def lookup_pde'_def get_pde'_def decode_heap_pde'_def ptable_trace'_def Let_def split: option.splits pde.splits)
lemma ptable_trace_get_pde':
"\<lbrakk> get_pde' (h(p \<mapsto> v)) r x = Some pde; p \<notin> ptable_trace' h r x \<rbrakk> \<Longrightarrow>
get_pde' h r x = Some pde "
apply (clarsimp simp: ptable_trace'_def Let_def get_pde'_def decode_heap_pde'_def )
by (case_tac " decode_pde (the (h (r r+ (vaddr_pd_index (addr_val x) << 2))))" ; clarsimp)
lemma [simp]:
"get_pde' h r va = Some (SectionPDE p perms) \<Longrightarrow>
decode_pde (the (h
(r r+ (vaddr_pd_index (addr_val va) << 2)))) = SectionPDE p perms "
by (clarsimp simp: get_pde'_def decode_heap_pde'_def)
lemma pt_table_lift_trace_upd'':
"p \<notin> ptable_trace' h r x \<Longrightarrow> ptable_lift' (h(p \<mapsto> v)) r x = ptable_lift' h r x"
apply (clarsimp simp: ptable_trace'_def Let_def ptable_lift'_def lookup_pde'_def get_pde'_def)
apply (subgoal_tac "decode_heap_pde' (h(p \<mapsto> v)) (r r+ (vaddr_pd_index (addr_val x) << 2)) =
decode_heap_pde' h (r r+ (vaddr_pd_index (addr_val x) << 2))")
apply clarsimp
apply (clarsimp simp: decode_heap_pde'_def)
apply (clarsimp split: option.splits)
apply (clarsimp split: pde.splits)
apply (clarsimp simp: lookup_pte'_def get_pte'_def)
apply (subgoal_tac "decode_heap_pte' (h(p \<mapsto> v)) (x3 r+ (vaddr_pt_index (addr_val x) << 2)) =
decode_heap_pte' h (x3 r+ (vaddr_pt_index (addr_val x) << 2))")
apply (clarsimp)
apply (clarsimp simp: decode_heap_pte'_def)
by (clarsimp simp: decode_heap_pde'_def decode_pde_def Let_def split: pde.splits)
(* page table look-up with mode and access permissions *)
definition
"user_perms perms = (arm_p_AP perms = 0x2 \<or> arm_p_AP perms = 0x3)"
definition
"filter_pde m = (\<lambda>x. case x of None \<Rightarrow> None
| Some (base, pg_size, perms) \<Rightarrow>
if (m = Kernel) \<or> (m = User \<and> user_perms perms)
then Some (base, pg_size, perms)
else None) "
definition
lookup_pde_perm :: "heap \<Rightarrow> paddr \<Rightarrow> mode_t \<Rightarrow> vaddr \<rightharpoonup> (paddr \<times> page_type \<times> arm_perm_bits)"
where
"lookup_pde_perm h r m vp = filter_pde m (lookup_pde' h r vp)"
definition
ptable_lift_m :: "heap \<Rightarrow> paddr \<Rightarrow> mode_t \<Rightarrow> vaddr \<rightharpoonup> paddr"
where
"ptable_lift_m h r m vp \<equiv>
map_option (\<lambda>(base, pg_size, perms). base r+ (vaddr_offset pg_size (addr_val vp)))
(lookup_pde_perm h r m vp) "
lemma lookup_pde_kernel[simp]:
"lookup_pde_perm h r Kernel vp = lookup_pde' h r vp"
by(clarsimp simp: lookup_pde_perm_def filter_pde_def split:option.splits)
lemma [simp]:
"ptable_lift_m h r Kernel va = ptable_lift' h r va"
by (clarsimp simp: ptable_lift_m_def ptable_lift'_def )
lemma ptable_lift_m_user [simp]:
"ptable_lift_m h r User va = Some pa \<Longrightarrow>
ptable_lift_m h r User va = ptable_lift' h r va"
by (clarsimp simp: ptable_lift_m_def ptable_lift'_def lookup_pde_perm_def filter_pde_def split: option.splits if_split_asm)
lemma ptlift_trace_some':
"ptable_lift_m h r m vp = Some pa \<Longrightarrow> ptable_trace' h r vp \<noteq> {}"
by (case_tac m , simp add: ptlift_trace_some , simp, frule ptable_lift_m_user, simp add: ptlift_trace_some)
lemma ptable_trace_preserved_m:
"\<lbrakk>ptable_lift_m h r m vp = Some pb; p \<notin> ptable_trace' h r vp;
pa \<notin> ptable_trace' h r vp \<rbrakk> \<Longrightarrow> pa \<notin> ptable_trace' (h(p \<mapsto> v)) r vp"
by (case_tac m ,simp add: ptable_trace_preserved', simp, frule ptable_lift_m_user, simp add: ptable_trace_preserved')
lemma ptable_lift_user_implies_ptable_lift:
"ptable_lift_m h r User va = Some pa \<Longrightarrow> ptable_lift' h r va = Some pa"
by (clarsimp simp: ptable_lift_m_def lookup_pde_perm_def filter_pde_def
ptable_lift'_def split:option.splits if_split_asm)
lemma ptable_lift_preserved_m:
"\<lbrakk>p \<notin> ptable_trace' h r vp; ptable_lift_m h r m vp = Some pa\<rbrakk> \<Longrightarrow> ptable_lift_m (h(p \<mapsto> v)) r m vp = Some pa"
apply (case_tac m ; simp add: ptable_lift_preserved')
apply (frule ptable_lift_m_user ; simp)
apply (frule_tac pa = pa and v = v in ptable_lift_preserved' , simp)
apply (clarsimp simp: ptable_trace'_def Let_def ptable_lift'_def lookup_pde'_def get_pde'_def split: option.splits)
apply (case_tac x2 ; clarsimp)
prefer 2
apply (clarsimp simp: decode_heap_pde'_def)
apply (clarsimp simp: ptable_lift_m_def lookup_pde'_def get_pde'_def decode_heap_pde'_def lookup_pde_perm_def filter_pde_def)
apply (clarsimp simp: ptable_lift_m_def lookup_pde'_def get_pde'_def lookup_pde_perm_def filter_pde_def lookup_pte'_def get_pte'_def decode_heap_pte'_def
split:if_split_asm split: option.splits)
by (case_tac "decode_pte x2" ; clarsimp simp: decode_heap_pde'_def lookup_pte'_def get_pte'_def decode_heap_pte'_def)
lemma ptable_lift_m_implies_ptlift:
"ptable_lift_m (heap s) (root s) (mode s) (Addr vp) = Some p \<Longrightarrow> ptable_lift' (heap s) (root s) (Addr vp) = Some p"
by (clarsimp simp: ptable_lift_m_def ptable_lift'_def lookup_pde_perm_def filter_pde_def user_perms_def split: option.splits if_split_asm)
lemma union_imp_all:
"p \<notin> \<Union>(ptable_trace' h r ` UNIV) \<Longrightarrow> \<forall>x. p \<notin> ptable_trace' h r x"
by (clarsimp)
(* Mapped page table, used for later in the kernel execution *)
definition
ptable_mapped :: "heap \<Rightarrow> paddr \<Rightarrow> vaddr set"
where
"ptable_mapped h r \<equiv> {va. \<exists>p. ptable_lift' h r va = Some p \<and> p \<in> \<Union>(ptable_trace' h r ` UNIV) } "
(* Memory Operations for Logic *)
definition
mem_read_hp' :: "vaddr set \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> mode_t \<Rightarrow> vaddr \<rightharpoonup> val"
where
"mem_read_hp' iset hp rt m vp \<equiv> if vp \<notin> iset then
(ptable_lift_m hp rt m \<rhd>o load_value_word_hp hp) vp else None"
definition "pagetable_lookup \<equiv> ptable_lift_m"
definition
if_filter :: "bool \<Rightarrow> 'a option \<rightharpoonup> 'a" (infixl "\<then>" 55)
where
"if_filter a b \<equiv> if a then b else None"
definition
"physical_address iset hp rt m va \<equiv> (va \<notin> iset) \<then> pagetable_lookup hp rt m va"
definition
mem_read_hp'' :: "vaddr set \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> mode_t \<Rightarrow> vaddr \<rightharpoonup> val"
where
"mem_read_hp'' iset hp rt m va \<equiv>
(physical_address iset hp rt m \<rhd>o load_value_word_hp hp) va"
definition
"fun_update' f g v \<equiv>
case f of Some y \<Rightarrow> Some (g (y \<mapsto> v))
| None \<Rightarrow> None "
definition
mem_write :: "vaddr set \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> mode_t \<Rightarrow> vaddr \<Rightarrow> val \<rightharpoonup> heap"
where
"mem_write iset hp rt m va v \<equiv>
fun_update' (physical_address iset hp rt m va) hp v "
(*Flush Operations for incon_set *)
datatype flush_type = flushTLB
| flushASID asid
| flushvarange "vaddr set"
| flushASIDvarange asid "vaddr set"
(* ptable_comp function *)
fun word_bits :: "nat \<Rightarrow> nat \<Rightarrow> 'a::len word \<Rightarrow> 'a::len word" where
"word_bits h l w = (w >> l) AND mask (Suc h - l)"
fun word_extract :: "nat \<Rightarrow> nat \<Rightarrow> 'a::len word \<Rightarrow> 'b::len word" where
"word_extract h l w = ucast (word_bits h l w)"
definition
to_tlb_flags :: "arm_perm_bits \<Rightarrow> tlb_flags"
where
"to_tlb_flags perms \<equiv> \<lparr>nG = arm_p_nG perms, perm_APX = arm_p_APX perms, perm_AP = arm_p_AP perms, perm_XN = arm_p_XN perms \<rparr>"
definition "tag_conv (a::asid) fl \<equiv> (if nG fl = 0 then None else Some a)"
definition
pdc_walk :: "asid \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> vaddr \<Rightarrow> pdc_entry option"
where
"pdc_walk a hp rt v \<equiv>
case get_pde' hp rt v
of Some (SectionPDE p perms) \<Rightarrow> Some (PDE_Section
(tag_conv a (to_tlb_flags perms))
(ucast (addr_val v >> 20) :: 12 word)
(addr_val p)
(to_tlb_flags perms))
| Some (PageTablePDE p) \<Rightarrow> Some (PDE_Table a (ucast (addr_val v >> 20) :: 12 word) (addr_val p))
| _ \<Rightarrow> None"
definition
pte_tlb_entry :: "asid \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> vaddr \<Rightarrow> tlb_entry option"
where
"pte_tlb_entry a hp p v \<equiv> case get_pte' hp p v
of Some (SmallPagePTE p' perms) \<Rightarrow> Some (EntrySmall (tag_conv a (to_tlb_flags perms))
(ucast (addr_val v >> 12) :: 20 word)
((word_extract 31 12 (addr_val p')):: 20 word)
(to_tlb_flags perms))
| _ \<Rightarrow> None"
fun
pde_tlb_entry :: "pdc_entry \<Rightarrow> heap \<Rightarrow> vaddr \<Rightarrow> tlb_entry option"
where
"pde_tlb_entry (PDE_Section a vba pba flags) mem va = Some (EntrySection a (ucast (addr_val va >> 20) :: 12 word) ((ucast (pba >> 20)) :: 12 word) flags)"
| "pde_tlb_entry (PDE_Table a vba pba) mem va = pte_tlb_entry a mem (Addr pba) va"
definition
map_opt :: "('a \<Rightarrow> 'b option) \<Rightarrow> 'a option \<Rightarrow> 'b option"
where
"map_opt f x \<equiv> case x of None \<Rightarrow> None | Some y \<Rightarrow> f y"
definition
pt_walk :: "asid \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> vaddr \<Rightarrow> tlb_entry option"
where
"pt_walk a m r v \<equiv> map_opt (\<lambda>pde. pde_tlb_entry pde m v) (pdc_walk a m r v)"
definition
pt_walk_pair :: "asid \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> vaddr \<Rightarrow> pt_walk_typ"
where
"pt_walk_pair a mem ttbr0 v \<equiv>
case pdc_walk a mem ttbr0 v
of None \<Rightarrow> Fault
| Some pde \<Rightarrow> (case pde_tlb_entry pde mem v
of None \<Rightarrow> Partial_Walk pde
| Some tlbentry \<Rightarrow> Full_Walk tlbentry pde)"
definition
entry_leq :: "pt_walk_typ \<Rightarrow> pt_walk_typ \<Rightarrow> bool" ("(_/ \<preceq> _)" [51, 51] 50)
where
"a \<preceq> b \<equiv> a = Fault \<or> a = b \<or> (\<exists>y. a = Partial_Walk y \<and> (\<exists>x. b = Full_Walk x y))"
definition
entry_less :: "pt_walk_typ \<Rightarrow> pt_walk_typ \<Rightarrow> bool" ("(_/ \<prec> _)" [51, 51] 50)
where
"a \<prec> b = (a \<preceq> b \<and> a \<noteq> b)"
interpretation entry: order entry_leq entry_less
apply unfold_locales
by (auto simp: entry_leq_def entry_less_def)
(* faults *)
definition
"is_fault e \<equiv> (e = None)"
definition
ptable_comp :: "(vaddr \<Rightarrow> pt_walk_typ) \<Rightarrow> (vaddr \<Rightarrow> pt_walk_typ) \<Rightarrow> vaddr set"
where
"ptable_comp walk walk' \<equiv> {va. \<not>(walk va \<preceq> walk' va)}"
definition
incon_comp :: "asid \<Rightarrow> asid \<Rightarrow> heap \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> paddr \<Rightarrow> vaddr set"
where
"incon_comp a a' hp hp' rt rt' \<equiv> ptable_comp (pt_walk_pair a hp rt) (pt_walk_pair a' hp' rt')"
lemma ptable_trace_pde_comp:
"\<forall>x. p \<notin> ptable_trace' h r x \<Longrightarrow> incon_comp a a h (h(p \<mapsto> v)) r r= {}"
apply (clarsimp simp: ptable_trace'_def incon_comp_def ptable_comp_def Let_def)
apply (drule_tac x = x in spec)
apply (clarsimp simp: entry_leq_def pt_walk_pair_def pdc_walk_def pte_tlb_entry_def get_pde'_def
decode_heap_pde'_def decode_pde_def split: option.splits pde.splits pte.splits)
using Let_def apply auto [1]
apply (clarsimp simp: Let_def split: if_split_asm)
apply (clarsimp simp: Let_def split: if_split_asm)
using Let_def apply auto [1]
apply (clarsimp simp: Let_def split: if_split_asm)
apply (clarsimp simp: Let_def split: if_split_asm)
using Let_def apply auto [1]
apply (clarsimp simp: Let_def pte_tlb_entry_def get_pte'_def decode_heap_pte'_def split: if_split_asm option.splits pte.splits)
apply (clarsimp simp: Let_def pte_tlb_entry_def get_pte'_def decode_heap_pte'_def split: if_split_asm option.splits pte.splits)
using Let_def apply auto [1]
apply (clarsimp simp: Let_def pte_tlb_entry_def get_pte'_def decode_heap_pte'_def split: if_split_asm option.splits pte.splits) +
done
lemma pde_comp_empty:
"p \<notin> \<Union>(ptable_trace' h r ` UNIV) \<Longrightarrow> incon_comp a a h (h(p \<mapsto> v)) r r = {}"
apply (drule union_imp_all)
by (clarsimp simp: ptable_trace_pde_comp)
lemma plift_equal_not_in_pde_comp [simp]:
"\<lbrakk>pt_walk_pair a h r va = e ; pt_walk_pair a h' r va = e \<rbrakk> \<Longrightarrow>
va \<notin> incon_comp a a h h' r r"
by (clarsimp simp: incon_comp_def ptable_comp_def)
lemma pt_walk_pair_pt_trace_upd:
"p \<notin> ptable_trace' h r x \<Longrightarrow> pt_walk_pair a h r x = pt_walk_pair a (h(p \<mapsto> v)) r x"
apply (clarsimp simp: ptable_trace'_def Let_def pt_walk_pair_def pdc_walk_def)
apply (subgoal_tac "get_pde' h r x = get_pde' (h(p \<mapsto> v)) r x" , clarsimp)
apply (cases "get_pde' (h(p \<mapsto> v)) r x" ;clarsimp)
apply (case_tac aa ; clarsimp simp: pte_tlb_entry_def)
apply (subgoal_tac "get_pte' h x3 x = get_pte' (h(p \<mapsto> v)) x3 x")
apply clarsimp
apply (clarsimp simp: get_pde'_def decode_heap_pde'_def get_pte'_def decode_heap_pte'_def)
by (clarsimp simp: get_pde'_def decode_heap_pde'_def Let_def split: pde.splits)
lemma pt_walk_pt_trace_upd:
"p \<notin> ptable_trace' h r x \<Longrightarrow> pt_walk a h r x = pt_walk a (h(p \<mapsto> v)) r x"
apply (clarsimp simp: ptable_trace'_def Let_def pt_walk_def pdc_walk_def map_opt_def)
apply (subgoal_tac "get_pde' h r x = get_pde' (h(p \<mapsto> v)) r x" , clarsimp)
apply (cases "get_pde' (h(p \<mapsto> v)) r x" ;clarsimp)
apply (case_tac aa ; clarsimp simp: pte_tlb_entry_def)
apply (subgoal_tac "get_pte' h x3 x = get_pte' (h(p \<mapsto> v)) x3 x")
apply clarsimp
apply (clarsimp simp: get_pde'_def decode_heap_pde'_def get_pte'_def decode_heap_pte'_def)
by (clarsimp simp: get_pde'_def decode_heap_pde'_def Let_def split: pde.splits)
lemma pt_trace_upd:
"p \<notin> ptable_trace' h r x \<Longrightarrow> ptable_trace' (h (p \<mapsto> v)) r x = ptable_trace' h r x"
by (clarsimp simp: ptable_trace'_def Let_def split: pde.splits)
lemma pt_table_lift_trace_upd:
"p \<notin> ptable_trace' h r x \<Longrightarrow> ptable_lift_m (h(p \<mapsto> v)) r m x = ptable_lift_m h r m x"
apply (clarsimp simp: ptable_trace'_def Let_def ptable_lift_m_def
lookup_pde_perm_def lookup_pde'_def get_pde'_def)
apply (subgoal_tac "decode_heap_pde' (h(p \<mapsto> v)) (r r+ (vaddr_pd_index (addr_val x) << 2)) =
decode_heap_pde' h (r r+ (vaddr_pd_index (addr_val x) << 2))")
apply clarsimp
apply (clarsimp simp: decode_heap_pde'_def)
apply (clarsimp split: option.splits)
apply (clarsimp split: pde.splits)
apply (clarsimp simp: lookup_pte'_def get_pte'_def)
apply (subgoal_tac "decode_heap_pte' (h(p \<mapsto> v)) (x3 r+ (vaddr_pt_index (addr_val x) << 2)) =
decode_heap_pte' h (x3 r+ (vaddr_pt_index (addr_val x) << 2))")
apply (clarsimp)
apply (clarsimp simp: decode_heap_pte'_def)
by (clarsimp simp: decode_heap_pde'_def decode_pde_def Let_def split: pde.splits)
lemma pt_table_lift_trace_upd':
"p \<notin> ptable_trace' h r x \<Longrightarrow> ptable_lift' h r x = ptable_lift' (h(p \<mapsto> v)) r x"
apply (clarsimp simp: ptable_trace'_def Let_def ptable_lift'_def
lookup_pde_perm_def lookup_pde'_def get_pde'_def)
apply (subgoal_tac "decode_heap_pde' (h(p \<mapsto> v)) (r r+ (vaddr_pd_index (addr_val x) << 2)) =
decode_heap_pde' h (r r+ (vaddr_pd_index (addr_val x) << 2))")
apply clarsimp
apply (clarsimp simp: decode_heap_pde'_def)
apply (clarsimp split: option.splits)
apply (clarsimp split: pde.splits)
apply (clarsimp simp: lookup_pte'_def get_pte'_def)
apply (subgoal_tac "decode_heap_pte' (h(p \<mapsto> v)) (x3 r+ (vaddr_pt_index (addr_val x) << 2)) =
decode_heap_pte' h (x3 r+ (vaddr_pt_index (addr_val x) << 2))")
apply (clarsimp)
apply (clarsimp simp: decode_heap_pte'_def)
by (clarsimp simp: decode_heap_pde'_def decode_pde_def Let_def split: pde.splits)
lemma pt_walk_pt_trace_upd':
"p \<notin> ptable_trace' h r x \<Longrightarrow> pt_walk a (h(p \<mapsto> v)) r x = pt_walk a h r x"
using pt_walk_pt_trace_upd by auto
lemma pt_walk_pair_pt_trace_upd':
"p \<notin> ptable_trace' h r x \<Longrightarrow> pt_walk_pair a (h(p \<mapsto> v)) r x = pt_walk_pair a h r x"
using pt_walk_pair_pt_trace_upd by auto
lemma no_fault_pt_walk_no_fault_pdc_walk:
"\<not>is_fault (pt_walk a m r va) \<Longrightarrow> \<not>is_fault (pdc_walk a m r va)"
by (clarsimp simp: is_fault_def pt_walk_def map_opt_def split: option.splits)
lemma pt_walk_pair_no_fault_pdc_walk:
"\<lbrakk>pt_walk_pair a m rt v = Full_Walk entry entry'\<rbrakk> \<Longrightarrow> pdc_walk a m rt v = Some entry'"
by (clarsimp simp: pt_walk_pair_def pdc_walk_def split: option.splits pde.splits pte.splits)
lemma pt_walk_pair_pair_fault_pdc_walk:
"\<lbrakk>pt_walk_pair a m r v = Partial_Walk y\<rbrakk> \<Longrightarrow> pdc_walk a m r v = Some y"
by (clarsimp simp: pt_walk_pair_def is_fault_def pdc_walk_def split: option.splits pde.splits pte.splits)
lemma pt_walk_pair_fault_pdc_walk_fault':
"\<lbrakk>pt_walk_pair a m rt v = Fault\<rbrakk> \<Longrightarrow> pdc_walk a m rt v = None"
by (clarsimp simp: pt_walk_pair_def pdc_walk_def split: option.splits pde.splits pte.splits)
lemma pt_walk_pair_fault_pt_walk_fault':
"\<lbrakk>pt_walk_pair a m rt v = Fault\<rbrakk> \<Longrightarrow> pt_walk a m rt v = None"
by (clarsimp simp: pt_walk_pair_def pt_walk_def map_opt_def pdc_walk_def split: option.splits pde.splits pte.splits)
lemma pt_walk_pair_equal_pdc_walk:
"pt_walk_pair a m rt v = pt_walk_pair a' m' rt' v \<Longrightarrow> pdc_walk a m rt v = pdc_walk a' m' rt' v"
by (cases "pt_walk_pair a m rt v"; cases "pt_walk_pair a' m' rt' v";
clarsimp simp: pt_walk_pair_fault_pdc_walk_fault' pt_walk_pair_pair_fault_pdc_walk
pt_walk_pair_no_fault_pdc_walk)
lemma pt_walk_pair_equal_pdc_walk':
"\<lbrakk>pt_walk_pair a m rt v = pt_walk_pair a' m' rt' v\<rbrakk> \<Longrightarrow>
the(pdc_walk a m rt v) = the(pdc_walk a' m' rt' v)"
by (cases "pt_walk_pair a m rt v"; cases "pt_walk_pair a' m' rt' v";
clarsimp simp: pt_walk_pair_fault_pdc_walk_fault' pt_walk_pair_pair_fault_pdc_walk
pt_walk_pair_no_fault_pdc_walk)
lemma pt_walk_pair_pdc_no_fault:
"\<lbrakk>pt_walk_pair a m rt v = pt_walk_pair a' m' rt' v; \<not>is_fault (pdc_walk a' m' rt' v) \<rbrakk> \<Longrightarrow>
\<not>is_fault (pdc_walk a m rt v)"
by (cases "pt_walk_pair a m rt v"; cases "pt_walk_pair a' m' rt' v";
clarsimp simp: pt_walk_pair_fault_pdc_walk_fault' pt_walk_pair_pair_fault_pdc_walk
pt_walk_pair_no_fault_pdc_walk)
lemma pt_walk_pair_fault_pt_walk_fault:
"\<lbrakk>pt_walk_pair a m r v = Partial_Walk y\<rbrakk> \<Longrightarrow> is_fault (pt_walk a m r v)"
by (clarsimp simp: pt_walk_pair_def is_fault_def pt_walk_def map_opt_def split: option.splits pde.splits)
lemma pt_walk_pair_no_fault_pt_walk:
"\<lbrakk>pt_walk_pair a m rt v = Full_Walk entry entry'\<rbrakk> \<Longrightarrow> pt_walk a m rt v = Some entry"
by (clarsimp simp: pt_walk_pair_def pt_walk_def map_opt_def split: option.splits pde.splits pte.splits)
lemma pt_walk_pair_no_fault_pt_walk':
"pt_walk_pair a m r v = Full_Walk te pe \<Longrightarrow> \<not>is_fault (pt_walk a m r v)"
by (simp add: is_fault_def pt_walk_pair_no_fault_pt_walk)
lemma pt_walk_full_no_pdc_fault:
"pt_walk_pair a m r v = Full_Walk te pe \<Longrightarrow> \<not>is_fault (pdc_walk a m r v)"
using no_fault_pt_walk_no_fault_pdc_walk pt_walk_pair_no_fault_pt_walk' by auto
lemma pt_walk_pair_pt_no_fault:
"\<lbrakk>pt_walk_pair a m rt v = pt_walk_pair a' m' rt' v; \<not>is_fault (pt_walk a' m' rt' v) \<rbrakk> \<Longrightarrow>
\<not>is_fault (pt_walk a m rt v)"
by (cases "pt_walk_pair a m rt v"; cases "pt_walk_pair a' m' rt' v";
clarsimp simp: pt_walk_pair_fault_pt_walk_fault' pt_walk_pair_fault_pt_walk_fault
pt_walk_pair_no_fault_pt_walk')
lemma pdc_walk_pt_trace_upd:
"p \<notin> ptable_trace' h r x \<Longrightarrow> pdc_walk a (h(p \<mapsto> v)) r x = pdc_walk a h r x"
apply (clarsimp simp: ptable_trace'_def Let_def pdc_walk_def split: option.splits)
apply (subgoal_tac "get_pde' h r x = get_pde' (h(p \<mapsto> v)) r x" , clarsimp)
by (clarsimp simp: get_pde'_def decode_pde_def Let_def decode_heap_pde'_def split: pde.splits if_split_asm)
lemma pt_walk_not_full_walk_fault:
"pt_walk_pair a m r v \<noteq> Full_Walk (the (pt_walk a m r v)) (the (pdc_walk a m r v)) \<Longrightarrow>
is_fault (pt_walk a m r v)"
by (clarsimp simp: pt_walk_pair_def is_fault_def pt_walk_def map_opt_def split: option.splits)
lemma pt_walk_not_full_walk_partial_pdc:
"\<lbrakk>\<forall>te. pt_walk_pair a m r v \<noteq> Full_Walk te (the (pdc_walk a m r v));
\<not>is_fault (pdc_walk a m r v)\<rbrakk> \<Longrightarrow> pt_walk_pair a m r v = Partial_Walk (the (pdc_walk a m r v))"
by (metis is_fault_def le_boolD option.sel order_refl pt_walk_not_full_walk_fault pt_walk_pair_fault_pdc_walk_fault'
pt_walk_pair_no_fault_pt_walk' pt_walk_pair_pair_fault_pdc_walk pt_walk_typ.exhaust)
lemma pt_walk_pair_disj:
"pt_walk_pair a m r v = Fault \<or> pt_walk_pair a m r v = Partial_Walk (the (pdc_walk a m r v)) \<or>
pt_walk_pair a m r v = Full_Walk (the (pt_walk a m r v)) (the (pdc_walk a m r v))"
by (clarsimp simp: pt_walk_pair_def is_fault_def pt_walk_def map_opt_def split: option.splits)
(* snapshot functions *)
definition
cur_pt_snp :: "vaddr set \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> asid \<Rightarrow> (vaddr set \<times> (vaddr \<Rightarrow> pt_walk_typ))"
where
"cur_pt_snp ist m r \<equiv> \<lambda>a. (ist, \<lambda>v. pt_walk_pair a m r v)"
definition
cur_pt_snp' :: "(asid \<Rightarrow> (vaddr set \<times> (vaddr \<Rightarrow> pt_walk_typ))) \<Rightarrow> vaddr set \<Rightarrow>
heap \<Rightarrow> paddr \<Rightarrow> asid \<Rightarrow> (asid \<Rightarrow> (vaddr set \<times> (vaddr \<Rightarrow> pt_walk_typ)))"
where
"cur_pt_snp' snp ist mem ttbr0 a \<equiv> snp (a := cur_pt_snp ist mem ttbr0 a)"
definition
"range_of (e :: tlb_entry) \<equiv>
case e of EntrySmall a vba pba fl \<Rightarrow> Addr ` {(ucast vba) << 12 ..
((ucast vba) << 12) + (2^12 - 1)}
| EntrySection a vba pba fl \<Rightarrow> Addr ` {(ucast vba) << 20 ..
((ucast vba) << 20) + (2^20 - 1)}"
definition
global_entries :: " tlb_entry set \<Rightarrow> tlb_entry set"
where
"global_entries t = {e\<in>t. asid_of e = None}"
definition
incon_load :: "ptable_snapshot \<Rightarrow> vaddr set \<Rightarrow> vaddr set \<Rightarrow> asid \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> vaddr set"
where
"incon_load snp iset gset a m r \<equiv> fst (snp a) \<union> (iset \<inter> gset) \<union> ptable_comp (snd(snp a)) (pt_walk_pair a m r)"
fun
flush_effect_iset ::"flush_type \<Rightarrow> vaddr set \<Rightarrow> vaddr set \<Rightarrow> asid \<Rightarrow> vaddr set"
where
"flush_effect_iset flushTLB iset gset a' = {}"
|
"flush_effect_iset (flushASID a) iset gset a' = (if a = a' then iset \<inter> gset else iset)"
|
"flush_effect_iset (flushvarange vset) iset gset a' = iset - vset"
|
"flush_effect_iset (flushASIDvarange a vset) iset gset a' = (if a = a' then iset - (vset - gset) else iset)"
fun
flush_effect_glb ::"flush_type \<Rightarrow> vaddr set \<Rightarrow> asid \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> vaddr set"
where
"flush_effect_glb flushTLB gset a' m rt = (\<Union>x\<in>global_entries (ran(pt_walk a' m rt)). range_of x)"
|
"flush_effect_glb (flushASID a) gset a' m rt = gset"
|
"flush_effect_glb (flushvarange vset) gset a' m rt = (gset - vset) \<union> (\<Union>x\<in>global_entries (ran(pt_walk a' m rt)). range_of x)"
|
"flush_effect_glb (flushASIDvarange a vset) gset a' m rt = gset"
fun
flush_effect_snp :: "flush_type \<Rightarrow> ptable_snapshot \<Rightarrow> asid \<Rightarrow> ptable_snapshot"
where
"flush_effect_snp flushTLB snp a' = (\<lambda>a. ({}, \<lambda>v. Fault))"
|
"flush_effect_snp (flushASID a) snp a'= (if a = a' then snp else snp(a := ({}, \<lambda>v. Fault)))"
|
"flush_effect_snp (flushvarange vset) snp a' = (\<lambda>a. (fst (snp a) - vset, \<lambda>v. if v \<in> vset then Fault else snd (snp a) v ))"
|
"flush_effect_snp (flushASIDvarange a vset) snp a'= (if a = a' then snp else
(\<lambda>x. if x = a then (fst (snp x) - vset, \<lambda>v. if v \<in> vset then Fault else snd (snp x) v) else snp x))"
(* for global set *)
definition
pt_walk' :: "asid \<Rightarrow> heap \<Rightarrow> paddr \<Rightarrow> vaddr \<Rightarrow> tlb_entry option"
where
"pt_walk' a hp rt v \<equiv>
case get_pde' hp rt v
of None \<Rightarrow> None
| Some InvalidPDE \<Rightarrow> None
| Some ReservedPDE \<Rightarrow> None
| Some (SectionPDE bpa perms) \<Rightarrow> Some (EntrySection (tag_conv a (to_tlb_flags perms)) (ucast (addr_val v >> 20) :: 12 word)
((word_extract 31 20 (addr_val bpa)):: 12 word)
(to_tlb_flags perms))
| Some (PageTablePDE p) \<Rightarrow>
(case get_pte' hp p v
of None \<Rightarrow> None
| Some InvalidPTE \<Rightarrow> None
| Some (SmallPagePTE bpa perms) \<Rightarrow> Some(EntrySmall (tag_conv a (to_tlb_flags perms)) (ucast (addr_val v >> 12) :: 20 word)
((word_extract 31 12 (addr_val bpa)):: 20 word)
(to_tlb_flags perms)))"
lemma pt_walk'_pt_walk:
"pt_walk' a h rt v = pt_walk a h rt v"
apply (clarsimp simp: pt_walk'_def pt_walk_def pdc_walk_def pte_tlb_entry_def map_opt_def
mask_def split:option.splits pde.splits pte.splits )
by word_bitwise
lemma va_20_left [simp]:
fixes va :: "32 word"
shows "ucast (ucast (va >> 20) :: 12 word) << 20 \<le> va"
by word_bitwise
lemma va_12_left [simp]:
fixes va :: "32 word"
shows "ucast (ucast (va >> 12) :: 20 word) << 12 \<le> va"
by word_bitwise
lemma va_20_right [simp]:
fixes va :: "32 word"
shows "va \<le> (ucast (ucast (va >> 20) :: 12 word) << 20) + 0x000FFFFF"
by word_bitwise
lemma va_12_right [simp]:
fixes va :: "32 word"
shows "va \<le> (ucast (ucast (va >> 12) :: 20 word) << 12) + 0x00000FFF"
by word_bitwise
lemma va_offset_add:
" (va::32 word) : {ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12 ..
(ucast (ucast (x >> 12):: 20 word) << 12) + mask 12 } \<Longrightarrow>
\<exists>a. (0 \<le> a \<and> a \<le> mask 12) \<and>
va = (ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12) + a"
apply (rule_tac x = "va - (ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12) " in exI)
apply (clarsimp simp: mask_def)
apply uint_arith
done
lemma shift_to_mask:
"x AND NOT mask 12 = (ucast (ucast ((x::32 word) >> 12):: 20 word)::32 word) << 12"
apply (rule word_eqI)
apply (simp add : word_ops_nth_size word_size)
apply (simp add : nth_shiftr nth_shiftl nth_ucast)
apply auto
done
lemma nth_bits_false:
"\<lbrakk>(n::nat) < 20; (a::32 word) \<le> 0xFFF\<rbrakk> \<Longrightarrow> \<not>(a !! (n + 12))"
apply word_bitwise
apply clarsimp
apply (case_tac "n = 0")
apply clarsimp
apply (case_tac "n = 1")
apply clarsimp
apply (case_tac "n = 2")
apply clarsimp
apply (case_tac "n = 3")
apply clarsimp
apply (case_tac "n = 4")
apply clarsimp
apply (case_tac "n = 5")
apply clarsimp
apply (case_tac "n = 6")
apply clarsimp
apply (case_tac "n = 7")
apply clarsimp
apply (case_tac "n = 8")
apply clarsimp
apply (case_tac "n = 9")
apply clarsimp
apply (case_tac "n = 10")
apply clarsimp
apply (case_tac "n = 11")
apply clarsimp
apply (case_tac "n = 12")
apply clarsimp
apply (case_tac "n = 13")
apply clarsimp
apply (case_tac "n = 14")
apply clarsimp
apply (case_tac "n = 15")
apply clarsimp
apply (case_tac "n = 16")
apply clarsimp
apply (case_tac "n = 17")
apply clarsimp
apply (case_tac "n = 18")
apply clarsimp
apply (case_tac "n = 19")
apply clarsimp
apply (thin_tac "\<not> a !! P" for P)+
apply arith
done
lemma nth_bits_offset_equal: "\<lbrakk>n < 20 ; (a::32 word) \<le> 0x00000FFF \<rbrakk> \<Longrightarrow>
(((x::32 word) && 0xFFFFF000) || a) !! (n + 12) = x !! (n + 12)"
apply clarsimp
apply (rule iffI)
apply (erule disjE)
apply clarsimp
apply (clarsimp simp: nth_bits_false)
apply clarsimp
apply (simp only: test_bit_int_def [symmetric])
apply (case_tac "n = 0")
apply clarsimp
apply (case_tac "n = 1")
apply clarsimp
apply (case_tac "n = 2")
apply clarsimp
apply (case_tac "n = 3")
apply clarsimp
apply (case_tac "n = 4")
apply clarsimp
apply (case_tac "n = 5")
apply clarsimp
apply (case_tac "n = 6")
apply clarsimp
apply (case_tac "n = 7")
apply clarsimp
apply (case_tac "n = 8")
apply clarsimp
apply (case_tac "n = 9")
apply clarsimp
apply (case_tac "n = 10")
apply clarsimp
apply (case_tac "n = 11")
apply clarsimp
apply (case_tac "n = 12")
apply clarsimp
apply (case_tac "n = 13")
apply clarsimp
apply (case_tac "n = 14")
apply clarsimp
apply (case_tac "n = 15")
apply clarsimp
apply (case_tac "n = 16")
apply clarsimp
apply (case_tac "n = 17")
apply clarsimp
apply (case_tac "n = 18")
apply clarsimp
apply (case_tac "n = 19")
apply clarsimp
by presburger
lemma add_to_or:
"(a::32 word) \<le> 0xFFF \<Longrightarrow>
((x::32 word) && 0xFFFFF000) + a = (x && 0xFFFFF000) || a"
apply word_bitwise
apply clarsimp
using xor3_simps carry_simps apply auto
done
lemma va_offset_higher_bits:
" \<lbrakk>ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12 \<le> va ;
va \<le> (ucast (ucast (x >> 12):: 20 word) << 12) + 0x00000FFF \<rbrakk> \<Longrightarrow>
(ucast (x >> 12)::20 word) = (ucast ((va:: 32 word) >> 12)::20 word)"
apply (subgoal_tac "(va::32 word) : {ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12 ..
(ucast (ucast (x >> 12):: 20 word) << 12) + mask 12 }")
prefer 2
apply (clarsimp simp: mask_def)
apply (frule va_offset_add)
apply simp
apply (erule exE)
apply (erule conjE)
apply (simp add: mask_def)
apply (subgoal_tac "(ucast ((((ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12)::32 word) + a) >> 12):: 20 word) =
(ucast (((ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12)::32 word) >> 12):: 20 word) ")
apply clarsimp
apply (word_bitwise) [1]
apply (subgoal_tac "ucast ((ucast (ucast ((x::32 word) >> 12):: 20 word)::32 word) << 12 >> 12) =
(ucast (x >> 12) :: 20 word)")
prefer 2
apply (word_bitwise) [1]
apply simp
apply (clarsimp simp: shift_to_mask [symmetric])
apply (rule word_eqI)
apply (simp only: nth_ucast)
apply clarsimp
apply (subgoal_tac "n < 20")
prefer 2
apply word_bitwise [1]
apply clarsimp
apply (clarsimp simp: nth_shiftr)
apply (clarsimp simp: mask_def)
apply (frule_tac a = a in nth_bits_offset_equal) apply clarsimp
apply (drule_tac x= x in add_to_or)
apply (simp only: )
done
lemma n_bit_shift:
"\<lbrakk> \<forall>n::nat. n \<in> {12 .. 31} \<longrightarrow>(a::32 word) !! n = (b::32 word) !! n \<rbrakk> \<Longrightarrow> a >> 12 = b >> 12"
apply word_bitwise
by auto
lemma nth_bits_offset: "\<lbrakk> n \<in> {12..31} ; (a::32 word) \<le> 0x00000FFF \<rbrakk> \<Longrightarrow>
(x::32 word) !! n = (x && 0xFFFFF000 || a) !! n"
apply (rule iffI)
apply (case_tac "n = 12")
apply clarsimp
apply (case_tac "n = 13")
apply clarsimp
apply (case_tac "n = 14")
apply clarsimp
apply (case_tac "n = 15")
apply clarsimp
apply (case_tac "n = 16")
apply clarsimp
apply (case_tac "n = 17")
apply clarsimp
apply (case_tac "n = 18")
apply clarsimp
apply (case_tac "n = 19")
apply clarsimp
apply (case_tac "n = 20")
apply clarsimp
apply (case_tac "n = 21")
apply clarsimp
apply (case_tac "n = 22")
apply clarsimp
apply (case_tac "n = 23")
apply clarsimp
apply (case_tac "n = 24")
apply clarsimp
apply (case_tac "n = 25")
apply clarsimp
apply (case_tac "n = 26")
apply clarsimp
apply (case_tac "n = 27")
apply clarsimp
apply (case_tac "n = 28")
apply clarsimp
apply (case_tac "n = 29")
apply clarsimp
apply (case_tac "n = 30")
apply clarsimp
apply (case_tac "n = 31")
apply clarsimp
prefer 2
apply (case_tac "n = 12")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 13")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 14")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 15")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 16")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 17")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 18")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 19")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 20")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 21")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 22")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 23")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 24")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 25")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 26")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 27")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 28")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 29")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 30")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 31")
apply word_bitwise [1] apply clarsimp
apply clarsimp
apply arith
apply clarsimp
apply arith
done
lemma offset_mask_eq:
"\<lbrakk>ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12 \<le> va ;
va \<le> (ucast (ucast (x >> 12):: 20 word) << 12) + 0x00000FFF\<rbrakk>
\<Longrightarrow> (( x >> 12) && mask 8 << 2) = ((va >> 12) && mask 8 << 2)"
apply (subgoal_tac "(va::32 word) : {ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12 ..
(ucast (ucast (x >> 12):: 20 word) << 12) + mask 12 }")
prefer 2
apply (clarsimp simp: mask_def)
apply (frule va_offset_add)
apply simp
apply (erule exE)
apply (erule conjE)
apply (simp add: mask_def)
apply (rule_tac f = "(\<lambda>x. x && 0xFF << 2)" in arg_cong)
apply (clarsimp simp: shift_to_mask [symmetric])
apply (simp add: mask_def)
apply (rule n_bit_shift)
apply (rule allI)
apply (rule impI)
apply (frule_tac x= x in add_to_or)
apply (frule_tac x= x in nth_bits_offset)
apply (simp only:)+
done
lemma n_bit_shift_1:
"\<lbrakk> \<forall>n::nat. n \<in> {12 .. 31} \<longrightarrow>(a::32 word) !! n = (b::32 word) !! n \<rbrakk> \<Longrightarrow> a >> 20 = b >> 20"
apply word_bitwise
by auto
lemma offset_mask_eq_1:
"\<lbrakk>ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12 \<le> va ;
va \<le> (ucast (ucast (x >> 12):: 20 word) << 12) + 0x00000FFF\<rbrakk>
\<Longrightarrow>((x >> 20) && mask 12 << 2) = ((va >> 20) && mask 12 << 2)"
apply (subgoal_tac "(va::32 word) : {ucast (ucast ((x:: 32 word) >> 12):: 20 word) << 12 ..
(ucast (ucast (x >> 12):: 20 word) << 12) + mask 12 }")
prefer 2
apply (clarsimp simp: mask_def)
apply (frule va_offset_add)
apply simp
apply (erule exE)
apply (erule conjE)
apply (simp add: mask_def)
apply (rule_tac f = "(\<lambda>x. x && 0xFFF << 2)" in arg_cong)
apply (clarsimp simp: shift_to_mask [symmetric])
apply (simp add: mask_def)
apply (rule n_bit_shift_1)
apply (rule allI)
apply (rule impI)
apply (frule_tac x= x in add_to_or)
apply (frule_tac x= x in nth_bits_offset)
apply (simp only:)+
done
lemma va_offset_add_1:
" (va::32 word) : {ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20 ..
(ucast (ucast (x >> 20):: 12 word) << 20) + mask 20 } \<Longrightarrow>
\<exists>a. (0 \<le> a \<and> a \<le> mask 20) \<and>
va = (ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20) + a"
apply (rule_tac x = "va - (ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20) " in exI)
apply (clarsimp simp: mask_def)
apply uint_arith
done
lemma shift_to_mask_1:
"x AND NOT mask 20 = (ucast (ucast ((x::32 word) >> 20):: 12 word)::32 word) << 20"
apply (rule word_eqI)
apply (simp add : word_ops_nth_size word_size)
apply (simp add : nth_shiftr nth_shiftl nth_ucast)
apply auto
done
lemma nth_bits_false_1:
"\<lbrakk>(n::nat) < 12; (a::32 word) \<le> 0xFFFFF\<rbrakk> \<Longrightarrow> \<not>(a !! (n + 20))"
apply word_bitwise
apply clarsimp
apply (case_tac "n = 0")
apply clarsimp
apply (case_tac "n = 1")
apply clarsimp
apply (case_tac "n = 2")
apply clarsimp
apply (case_tac "n = 3")
apply clarsimp
apply (case_tac "n = 4")
apply clarsimp
apply (case_tac "n = 5")
apply clarsimp
apply (case_tac "n = 6")
apply clarsimp
apply (case_tac "n = 7")
apply clarsimp
apply (case_tac "n = 8")
apply clarsimp
apply (case_tac "n = 9")
apply clarsimp
apply (case_tac "n = 10")
apply clarsimp
apply (case_tac "n = 11")
apply clarsimp
apply (thin_tac "\<not> a !! P" for P)+
apply arith
done
lemma nth_bits_offset_equal_1: "\<lbrakk>n < 12 ; (a::32 word) \<le> 0x000FFFFF \<rbrakk> \<Longrightarrow>
(((x::32 word) && 0xFFF00000) || a) !! (n + 20) = x !! (n + 20)"
apply clarsimp
apply (rule iffI)
apply (erule disjE)
apply clarsimp
apply (clarsimp simp: nth_bits_false_1)
apply clarsimp
apply (simp only: test_bit_int_def [symmetric])
apply (case_tac "n = 0")
apply clarsimp
apply (case_tac "n = 1")
apply clarsimp
apply (case_tac "n = 2")
apply clarsimp
apply (case_tac "n = 3")
apply clarsimp
apply (case_tac "n = 4")
apply clarsimp
apply (case_tac "n = 5")
apply clarsimp
apply (case_tac "n = 6")
apply clarsimp
apply (case_tac "n = 7")
apply clarsimp
apply (case_tac "n = 8")
apply clarsimp
apply (case_tac "n = 9")
apply clarsimp
apply (case_tac "n = 10")
apply clarsimp
apply (case_tac "n = 11")
apply clarsimp
by presburger
lemma add_to_or_1:
"(a::32 word) \<le> 0xFFFFF \<Longrightarrow>
((x::32 word) && 0xFFF00000) + a = (x && 0xFFF00000) || a"
apply word_bitwise
apply clarsimp
using xor3_simps carry_simps apply auto
done
lemma va_offset_higher_bits_1:
" \<lbrakk>ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20 \<le> va ;
va \<le> (ucast (ucast (x >> 20):: 12 word) << 20) + 0x000FFFFF \<rbrakk> \<Longrightarrow>
(ucast (x >> 20):: 12 word) = (ucast ((va:: 32 word) >> 20)::12 word)"
apply (subgoal_tac "(va::32 word) : {ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20 ..
(ucast (ucast (x >> 20):: 12 word) << 20) + mask 20 }")
prefer 2
apply (clarsimp simp: mask_def)
apply (frule va_offset_add_1)
apply simp
apply (erule exE)
apply (erule conjE)
apply (simp add: mask_def)
apply (subgoal_tac "(ucast ((((ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20)::32 word) + a) >> 20):: 12 word) =
(ucast (((ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20)::32 word) >> 20):: 12 word) ")
apply clarsimp
apply (word_bitwise) [1]
apply (subgoal_tac "ucast ((ucast (ucast ((x::32 word) >> 20):: 12 word)::32 word) << 20 >> 20) =
(ucast (x >> 20) :: 12 word)")
prefer 2
apply (word_bitwise) [1]
apply simp
apply (clarsimp simp: shift_to_mask_1 [symmetric])
apply (rule word_eqI)
apply (simp only: nth_ucast)
apply clarsimp
apply (subgoal_tac "n < 12")
prefer 2
apply word_bitwise [1]
apply clarsimp
apply (clarsimp simp: nth_shiftr)
apply (clarsimp simp: mask_def)
apply (frule_tac a = a in nth_bits_offset_equal_1) apply clarsimp
apply (drule_tac x= x in add_to_or_1)
apply (simp only: )
done
lemma n_bit_shift_2:
"\<lbrakk> \<forall>n::nat. n \<in> {20 .. 31} \<longrightarrow>(a::32 word) !! n = (b::32 word) !! n \<rbrakk> \<Longrightarrow> a >> 20 = b >> 20"
apply word_bitwise
by auto
lemma nth_bits_offset_1: "\<lbrakk> n \<in> {20..31} ; (a::32 word) \<le> 0x000FFFFF \<rbrakk> \<Longrightarrow>
(x::32 word) !! n = (x && 0xFFF00000 || a) !! n"
apply (rule iffI)
apply (case_tac "n = 20")
apply clarsimp
apply (case_tac "n = 21")
apply clarsimp
apply (case_tac "n = 22")
apply clarsimp
apply (case_tac "n = 23")
apply clarsimp
apply (case_tac "n = 24")
apply clarsimp
apply (case_tac "n = 25")
apply clarsimp
apply (case_tac "n = 26")
apply clarsimp
apply (case_tac "n = 27")
apply clarsimp
apply (case_tac "n = 28")
apply clarsimp
apply (case_tac "n = 29")
apply clarsimp
apply (case_tac "n = 30")
apply clarsimp
apply (case_tac "n = 31")
apply clarsimp
prefer 2
apply (case_tac "n = 20")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 21")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 22")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 23")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 24")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 25")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 26")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 27")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 28")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 29")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 30")
apply word_bitwise [1] apply clarsimp
apply (case_tac "n = 31")
apply word_bitwise [1] apply clarsimp
apply clarsimp
apply arith
apply clarsimp
apply arith
done
lemma shfit_mask_eq:
"\<lbrakk>ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20 \<le> va ;
va \<le> (ucast (ucast (x >> 20):: 12 word) << 20) + 0x000FFFFF \<rbrakk>
\<Longrightarrow> ((x >> 20) && mask 12 << 2) = ((va >> 20) && mask 12 << 2)"
apply (subgoal_tac "(va::32 word) : {ucast (ucast ((x:: 32 word) >> 20):: 12 word) << 20 ..
(ucast (ucast (x >> 20):: 12 word) << 20) + mask 20 }")
prefer 2
apply (clarsimp simp: mask_def)
apply (frule va_offset_add_1)
apply simp
apply (erule exE)
apply (erule conjE)
apply (simp add: mask_def)
apply (rule_tac f = "(\<lambda>x. x && 0xFFF << 2)" in arg_cong)
apply (clarsimp simp: shift_to_mask_1 [symmetric])
apply (simp add: mask_def)
apply (rule n_bit_shift_2)
apply (rule allI)
apply (rule impI)
apply (frule_tac x= x in add_to_or_1)
apply (frule_tac x= x and a = a in nth_bits_offset_1)
apply (simp only:)+
done
lemma asid_entry_range [simp, intro!]:
"pt_walk' a m r v \<noteq> None \<Longrightarrow> v \<in> range_of (the (pt_walk' a m r v))"
apply (clarsimp simp: range_of_def pt_walk'_def Let_def split: option.splits )
apply (case_tac x2; clarsimp split: option.splits)
apply (case_tac x2a; clarsimp split: option.splits)
apply (metis (no_types, hide_lams) Addr_addr_val atLeastAtMost_iff image_iff va_12_left va_12_right)
by (metis (no_types, hide_lams) Addr_addr_val atLeastAtMost_iff image_iff va_20_left va_20_right)
lemma asid_va_entry_range_pt_entry:
"\<not>is_fault(pt_walk' a m r v) \<Longrightarrow>
v \<in> range_of (the(pt_walk' a m r v))"
by (clarsimp simp: is_fault_def)
lemma va_entry_set_pt_palk_same':
"\<lbrakk>\<not>is_fault (pt_walk a' m r x) ;
va \<in> range_of (the (pt_walk a' m r x))\<rbrakk> \<Longrightarrow>
pt_walk a' m r x = pt_walk a' m r va"
apply (simp only: pt_walk'_pt_walk [symmetric])
apply (subgoal_tac "x \<in> range_of (the(pt_walk' a' m r x))")
prefer 2
apply (clarsimp simp: asid_va_entry_range_pt_entry is_fault_def)
apply (cases "the (pt_walk' a' m r x)")
apply (simp only: )
apply (clarsimp simp: range_of_def is_fault_def)
apply (cases "get_pde' m r x" ; clarsimp simp: pt_walk'_def)
apply (case_tac a ; clarsimp)
apply (case_tac "get_pte' m x3 x " ; clarsimp)
apply (subgoal_tac "get_pde' m r (Addr xaa) = get_pde' m r (Addr xa)" ; clarsimp)
apply (subgoal_tac "get_pte' m x3 (Addr xaa) = get_pte' m x3 (Addr xa)" ; clarsimp)
apply (case_tac a ; clarsimp)
using va_offset_higher_bits apply blast
apply (case_tac a ; clarsimp)
apply (clarsimp simp: get_pte'_def vaddr_pt_index_def)
apply (subgoal_tac "(( xaa >> 12) && mask 8 << 2) =
(( xa >> 12) && mask 8 << 2) ")
prefer 2
using offset_mask_eq apply force
apply force
apply (case_tac a ; clarsimp)
apply (clarsimp simp: get_pde'_def vaddr_pd_index_def)
apply (subgoal_tac "((xaa >> 20) && mask 12 << 2) =
((xa >> 20) && mask 12 << 2) ")
prefer 2
using offset_mask_eq_1 apply force
apply force
apply (simp only: )
apply (clarsimp simp: range_of_def is_fault_def)
apply (cases "get_pde' m r x" ; clarsimp simp: pt_walk'_def)
apply (case_tac a ; clarsimp)
apply (case_tac "get_pte' m x3 x" ; clarsimp)
apply (subgoal_tac "get_pde' m r (Addr xaa) = get_pde' m r (Addr xa)" ; clarsimp)
apply (subgoal_tac "get_pte' m x3 (Addr xaa) = get_pte' m x3 (Addr xa)" ; clarsimp)
apply (case_tac a ; clarsimp)
apply (case_tac a ; clarsimp simp: get_pte'_def vaddr_pt_index_def)
apply (case_tac a ; clarsimp simp: get_pde'_def vaddr_pd_index_def)
apply (cases "get_pde' m r x" ; clarsimp)
apply (subgoal_tac "get_pde' m r (Addr xaa) = get_pde' m r (Addr xa)" ; clarsimp)
using va_offset_higher_bits_1 apply blast
apply (clarsimp simp: get_pde'_def vaddr_pd_index_def)
apply (subgoal_tac "((xaa >> 20) && mask 12 << 2) = ((xa >> 20) && mask 12 << 2)")
apply force
using shfit_mask_eq by force
end
|
#include <badem/rpc/rpc_connection_secure.hpp>
#include <badem/rpc/rpc_secure.hpp>
#include <boost/polymorphic_pointer_cast.hpp>
badem::rpc_connection_secure::rpc_connection_secure (badem::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, badem::logger_mt & logger, badem::rpc_handler_interface & rpc_handler_interface, boost::asio::ssl::context & ssl_context) :
badem::rpc_connection (rpc_config, io_ctx, logger, rpc_handler_interface),
stream (socket, ssl_context)
{
}
void badem::rpc_connection_secure::parse_connection ()
{
// Perform the SSL handshake
auto this_l = std::static_pointer_cast<badem::rpc_connection_secure> (shared_from_this ());
stream.async_handshake (boost::asio::ssl::stream_base::server,
[this_l](auto & ec) {
this_l->handle_handshake (ec);
});
}
void badem::rpc_connection_secure::on_shutdown (const boost::system::error_code & error)
{
// No-op. We initiate the shutdown (since the RPC server kills the connection after each request)
// and we'll thus get an expected EOF error. If the client disconnects, a short-read error will be expected.
}
void badem::rpc_connection_secure::handle_handshake (const boost::system::error_code & error)
{
if (!error)
{
read ();
}
else
{
logger.always_log ("TLS: Handshake error: ", error.message ());
}
}
void badem::rpc_connection_secure::write_completion_handler (std::shared_ptr<badem::rpc_connection> rpc)
{
auto rpc_connection_secure = boost::polymorphic_pointer_downcast<badem::rpc_connection_secure> (rpc);
rpc_connection_secure->stream.async_shutdown (boost::asio::bind_executor (rpc->strand, [rpc_connection_secure](auto const & ec_shutdown) {
rpc_connection_secure->on_shutdown (ec_shutdown);
}));
}
|
proposition maximum_modulus_principle: assumes holf: "f holomorphic_on S" and S: "open S" and "connected S" and "open U" and "U \<subseteq> S" and "\<xi> \<in> U" and no: "\<And>z. z \<in> U \<Longrightarrow> norm(f z) \<le> norm(f \<xi>)" shows "f constant_on S" |
# -*- coding: utf-8 -*-
'''
Texas A&M University Sounding Rocketry Team
SRT-6 | 2018-2019
SRT-9 | 2021-2022
%-------------------------------------------------------------%
TAMU SRT
_____ __ _____ __ __
/ ___/______ __ _____ ___/ / / ___/__ ___ / /________ / /
/ (_ / __/ _ \/ // / _ \/ _ / / /__/ _ \/ _ \/ __/ __/ _ \/ /
\___/_/ \___/\_,_/_//_/\_,_/ \___/\___/_//_/\__/_/ \___/_/
%-------------------------------------------------------------%
Filepath:
gc/srt_gc_launchGui/srt_gc_launchGui.py
Developers:
(C) Doddanavar, Roshan 20171216
(L) Doddanavar, Roshan 20180801
Diaz, Antonio
Description:
Launch Control GUI, interfaces w/ srt_gc_launchArduino/srt_gc_launchArduino.ino
Input(s):
<None>
Output(s):
./log/*.log plain-text command log
./dat/*.dat plain-text data archive
'''
# Installed modules --> Utilities
import sys
import os
import serial, serial.tools.list_ports
from serial.serialutil import SerialException
import time
from datetime import datetime
import numpy as np
# Installed modules --> PyQt related
from PyQt5 import (QtGui, QtCore, QtSvg)
from PyQt5.QtCore import (Qt, QThread, pyqtSignal, QDate, QTime, QDateTime, QSize)
from PyQt5.QtWidgets import (QMainWindow, QWidget, QDesktopWidget, QPushButton, QApplication, QGroupBox, QGridLayout, QStatusBar, QFrame, QTabWidget,QComboBox)
import pyqtgraph as pg
# Program modules
from srt_gc_launchState import State
from srt_gc_launchThread import SerThread, UptimeThread
from srt_gc_launchTools import Tools, Object
from srt_gc_launchStyle import Style, Color
from srt_gc_launchConstr import Constr
# used to monitor wifi networks.
import subprocess
# used to get date and time in clock method.
import datetime as dt
# used to connect to ethernet socket in connect method.
import socket
# data for ethernet connection to SRT6 router
# Create a TCP/IP socket for srt router
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
TCP_IP = '192.168.1.177'
TCP_PORT = 23
server_address = (TCP_IP, TCP_PORT)
class Gui(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
'''
Main Window Initialization
'''
# General initialization
self.session = ''
# current date used in top of window
self.dateGlobal = QDate.currentDate()
# current time used in starting thread time in bottom of window
self.startGlobal = QTime.currentTime()
self.version = "v6.4.0"
# Container initialization
self.edit = Object() # Line edit container
self.btn = Object() # Button container
self.led = Object() # LED indicator container
self.ledClr = Object() # LED pixmap container
self.sensor = Object() # Sensor readout container
self.data = Object() # Data array container
self.plot = Object() # Plot container
ledImg = ["green","yellow","red","off"] # LED indicator image files
for name in ledImg:
# get LED Images in figs folder, green.png, yellow.png, and so on
# pixmap = QtGui.QPixmap("./figs/" + name + ".png").scaled(20, 20,
pixmap = QtGui.QPixmap("./srt_gc_launchGui/figs/" + name + ".png").scaled(20, 20,
transformMode=QtCore.Qt.SmoothTransformation)
setattr(self.ledClr,name,pixmap)
# Utility initialization
self.style = Style()
self.color = Color()
self.state = State(self.led,self.ledClr)
self.tools = Tools()
self.constr = Constr(self,self.ledClr)
# Utility states
self.state.connected = False # Serial connection
self.state.reading = False # COM port bypass
self.state.log = False # Log/data file initialization
self.state.data = False # Avionics data read
# Master grid layout management
self.gridMaster = QGridLayout()
self.gridMaster.setSpacing(10)
# Tab initialization
# name, row, col, row Span, col Span
tabSpec = [( "tabComm", 0, 2, 1, 8),
( "tabSys", 1, 0, 1, 2),
( "tabAv", 1, 2, 1, 2),
( "tabFill", 1, 4, 1, 2),
( "tabData", 2, 0, 1, 10)]
for spec in tabSpec:
tabName = spec[0]
row = spec[1]
col = spec[2]
rSpan = spec[3]
cSpan = spec[4]
tab = QTabWidget()
setattr(self,tabName,tab)
self.gridMaster.addWidget(tab,row,col,rSpan,cSpan)
# kind, grid, title, row, col, row Span, col Span
groupSpec = [( "box", "groupTitle", "gridTitle", "", 0, 0, 1, 2),
( "tab", "groupComm", "gridComm", "Communication", "tabComm"),
( "tab", "groupSess", "gridSess", "Session Control", "tabComm"),
( "tab", "groupSys", "gridSys", "System State", "tabSys"),
( "tab", "groupPwr", "gridPwr", "Power Telemetry", "tabSys"),
( "tab", "groupDaq", "gridDaq", "Avionics DAQ", "tabAv"),
( "tab", "groupDiag", "gridDiag", "Diagnostics", "tabAv"),
( "tab", "groupFill", "gridFill", "Fill Control", "tabFill"),
( "tab", "groupAuto", "gridAuto", "Auto Fill", "tabFill"),
( "box", "groupIgn", "gridIgn", "Igniter Control", 1, 6, 1, 2),
( "box", "groupVal", "gridVal", "Valve Control", 1, 8, 1, 2),
( "tab", "groupPlot", "gridPlot", "Engine Diagnostics", "tabData"),
( "tab", "groupOut", "gridOut", "Serial Output", "tabData"),]
for spec in groupSpec:
kind = spec[0]
groupName = spec[1]
gridName = spec[2]
title = spec[3]
if (kind == "tab"):
parent = spec[4]
group = QWidget()
grid = QGridLayout()
# Widget initialization
setattr(self,groupName,group)
# GridLayout object initialization
setattr(self,gridName,grid)
group.setLayout(grid)
group.setAutoFillBackground(True)
# Tab assignment
getattr(self,parent).addTab(group,title)
elif (kind == "box"):
row = spec[4]
col = spec[5]
rSpan = spec[6]
cSpan = spec[7]
# GroupBox object initialization
group = QGroupBox(title)
group.setStyleSheet(self.style.css.group)
# GridLayout object initialization
grid = QGridLayout()
group.setLayout(grid)
# Assign to parent objects
setattr(self,gridName,grid)
setattr(self,groupName,group)
self.gridMaster.addWidget(group,row,col,rSpan,cSpan)
# Call initialization routines
self.titleInit() # Title bar
self.barInit() # Bottom statusbar
self.commInit() # Communication toolbar
self.sessInit() # Session toolbar
self.btnCtrlInit() # Buttons for control panel
self.ledCtrlInit() # LED inidicators " "
self.plotInit() # Engine diagnostics, plots
self.dataInit() # Engine diagnostics, readouts
self.outInit() # Raw serial output
# Row & column stretching in master grid
rowStr = [1, 4, 8]
colStr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
self.tools.resize(self.gridMaster,rowStr,colStr)
# Finalize widget
mainWidget = QWidget()
mainWidget.setLayout(self.gridMaster)
self.setCentralWidget(mainWidget)
# Window management
self.setWindowTitle("SRT Ground Control " + self.version + " " + self.dateGlobal.toString(Qt.TextDate))
self.setWindowIcon(QtGui.QIcon("./figs/desktop_icon.png"))
self.showMaximized()
# Window centering
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
# Window formatting
#self.setStyleSheet(self.style.css.window)
# Final initialization
self.show()
def titleInit(self):
'''
Window Title Initialization
'''
# QLabel --> SRT logo
#titImg = "./figs/srt_black.svg"
titImg = "./srt_gc_launchGui/figs/srt_black.svg"
pixmap = QtGui.QPixmap(titImg).scaled(50,50,transformMode=QtCore.Qt.SmoothTransformation)
self.logo = self.constr.image(self.gridTitle,pixmap,[0,0,2,1])
# QLabel --> Main window title
text = "SRT Ground Control" + " " + self.version
self.title = self.constr.label(self.gridTitle,"title",text,"Bottom",[0,1,1,1])
# QLabel --> Main window subtitle
text = "Remote Launch System [tamusrt/gc]"
self.subtitle = self.constr.label(self.gridTitle,"subtitle",text,"Top",[1,1,1,1])
# Row & column stretching in title grid
rowStr = [5, 1]
colStr = [1, 2]
self.tools.resize(self.gridTitle,rowStr,colStr)
def barInit(self):
'''
Initialize strings and inputs in bottom status bar.
'''
self.statusBar = QStatusBar()
self.setStatusBar(self.statusBar)
barFrame = QFrame()
gridStatus = QGridLayout()
barFrame.setLayout(gridStatus)
self.statusBar.addPermanentWidget(barFrame,1)
# Event log
self.constr.label(gridStatus,"label","EVENT LOG","Center",[0,0,1,1])
self.statusBar.log = self.constr.readout(gridStatus,"statusBar",[0,1,1,1])
# Last sent
self.constr.label(gridStatus,"label","LAST SENT","Center",[0,2,1,1])
self.statusBar.sent = self.constr.readout(gridStatus,"statusBar",[0,3,1,1])
# Last recieved
self.constr.label(gridStatus,"label","LAST RCVD","Center",[0,4,1,1])
self.statusBar.recieved = self.constr.readout(gridStatus,"statusBar",[0,5,1,1])
# Session name
self.constr.label(gridStatus,"label","SESSION","Center",[0,6,1,1])
self.statusBar.session = self.constr.readout(gridStatus,"statusBar",[0,7,1,1])
# Uptime counter
self.constr.label(gridStatus,"label","UPTIME","Center",[0,8,1,1])
self.statusBar.uptime = self.constr.readout(gridStatus,"statusBar",[0,9,1,1])
# Uptime thread management
self.uptimeThread = UptimeThread(self.startGlobal,self.statusBar.uptime)
self.uptimeThread.start()
# Row & column stretching in comm grid
rowStr = []
colStr = [1, 4, 1, 2, 1, 2, 1, 2, 1, 2]
self.tools.resize(gridStatus,rowStr,colStr)
def commInit(self):
'''
Communication Toolbar Initialization
'''
# set communication and reading status as false initially.
self.state.connected = False
self.state.reading = False
if (os.name == "posix"):
prefix = "/dev/tty"
elif (os.name == "nt"):
prefix = "COM"
else:
prefix = ""
# LED indicator for connection
self.led.commConn = self.constr.led(self.gridComm,[0,0,1,1])
# CONNECT button
method = "btnClkConn"
color = self.color.comm
self.btn.commConn = self.constr.button(self.gridComm,"CONNECT",method,color,[0,1,1,1])
# SEARCH button
method = "btnClkSearch"
color = self.color.comm
self.btn.commSearch = self.constr.button(self.gridComm,"SEARCH",method,color,[0,2,1,1])
# COM Port label & input
self.labPort = self.constr.label(self.gridComm,"label","Data Port:","Center",[0,3,1,1])
self.portMenu = self.constr.dropDown(self.gridComm,[0,4,1,1])
# Baud rate label & input
self.labBaud = self.constr.label(self.gridComm,"label","Baud Rate","Center",[0,5,1,1])
self.baudMenu = self.constr.dropDown(self.gridComm,[0,6,1,1])
self.baudMenu.addItems(["9600","14400","19200","28800","38400","57600","115200"])
# LED indicator for bypass
self.led.commByp = self.constr.led(self.gridComm,[0,7,1,1])
# BYPASS button. Function of bypass is to force GUI to send commands over xbee even if xbee port isn't showing.
method = "btnClkByp"
color = self.color.comm
self.btn.commByp = self.constr.button(self.gridComm,"BYPASS",method,color,[0,8,1,1])
# RESET button. Function of reset is to stop thread sorting, turn off all LEDs and disconnect xbees. May want to add more functionality such as returning to a safe state of the engine.
method = "btnClkRes"
color = self.color.comm
self.btn.commRes = self.constr.button(self.gridComm,"RESET",method,color,[0,9,1,1])
# Row & column stretching in comm grid
rowStr = []
colStr = [1, 3, 3, 2, 5, 2, 2, 1, 3, 3]
self.tools.resize(self.gridComm,rowStr,colStr)
def sessInit(self):
# Session name
self.led.sess = self.constr.led(self.gridSess,[0,0,1,1])
self.btn.sessNew = self.constr.button(self.gridSess,"NEW","btnClkSessNew",self.color.comm,[0,1,1,1])
self.btn.sessRename = self.constr.button(self.gridSess,"RENAME","btnClkSessRename",self.color.comm,[0,2,1,1])
self.labSess = self.constr.label(self.gridSess,"label","Session","Center",[0,3,1,1])
self.edit.session = self.constr.edit(self.gridSess,"test",[0,4,1,1])
# Clock control
self.led.clock = self.constr.led(self.gridSess,[0,5,1,1])
self.btn.sessClock = self.constr.button(self.gridSess,"SET CLOCK","btnClkClock",self.color.comm,[0,6,1,1])
self.labDateYr = self.constr.label(self.gridSess,"label","Date","Center",[0,7,1,1])
self.edit.dateYYYY = self.constr.edit(self.gridSess,"YYYY",[0,8,1,1])
self.edit.dateMM = self.constr.edit(self.gridSess,"MM",[0,9,1,1])
self.edit.dateDD = self.constr.edit(self.gridSess,"DD",[0,10,1,1])
self.labTime = self.constr.label(self.gridSess,"label","Time","Center",[0,11,1,1])
self.edit.timeHH = self.constr.edit(self.gridSess,"HH",[0,12,1,1])
self.edit.timeMM = self.constr.edit(self.gridSess,"MM",[0,13,1,1])
self.edit.timeSS = self.constr.edit(self.gridSess,"SS",[0,14,1,1])
# Row & column stretching in sess grid
rowStr = []
colStr = [1, 2, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1]
self.tools.resize(self.gridSess,rowStr,colStr)
def btnClkSearch(self):
# set the port menu to be cleared initially.
self.portMenu.clear()
# check the number of serial ports available.
ports = serial.tools.list_ports.comports()
# if ports exist, add it to drop down menu in GUI
if (ports):
for port in ports:
entry = "Serial: " + port.device + " - " + port.description
self.portMenu.addItem(entry)
# uses subprocess package to check for connected wifi networks.
devices = subprocess.check_output(['netsh','wlan','show','network']).decode('ascii').replace("\r","")
numOfWifiDevices = len(devices.split("SSID"))
# check to see the number of wifi networks we can connect to
if numOfWifiDevices:
for deviceNum in range(1, numOfWifiDevices):
entry = "Wifi Network: " + devices.split("SSID")[deviceNum].split(" ")[3]
self.portMenu.addItem(entry)
else:
self.portMenu.setCurrentText("NO DEVICE(S) FOUND")
def btnClkClock(self):
'''
"CLOCK" Button Event Handling
'''
# probably better to replace these with QDate class to reduce number of packages you have to import.
year = str(dt.datetime.now().year)
month = str(dt.datetime.now().month)
day = str(dt.datetime.now().day)
hour = str(datetime.now().hour)
minute = str(dt.datetime.now().minute)
seconds = str(dt.datetime.now().second)
# automatically update date and time log when button clicked
self.edit.dateYYYY = self.constr.edit(self.gridSess,year,[0,8,1,1])
self.edit.dateMM = self.constr.edit(self.gridSess,month,[0,9,1,1])
self.edit.dateDD = self.constr.edit(self.gridSess,day,[0,10,1,1])
self.edit.timeHH = self.constr.edit(self.gridSess,hour,[0,12,1,1])
self.edit.timeMM = self.constr.edit(self.gridSess,minute,[0,13,1,1])
self.edit.timeSS = self.constr.edit(self.gridSess,seconds,[0,14,1,1])
# I think this was meant to pull up exact date and time on a separate window for user to type in manually.
# This command below with os.system doesn't work. sudo command not recognized on windows.
# dateStr = self.edit.dateYYYY.text() + '-' + self.edit.dateMM.text() + '-' + self.edit.dateDD.text()
# timeStr = self.edit.timeHH.text() + ':' + self.edit.timeMM.text() + ':' + self.edit.timeSS.text()
# cmdStr = "sudo date -s"
# System command
# sudo date -s 'YYYY-MM-DD HH:MM:SS'
#os.system('cmdStr' + ' ' + '\'' + dateStr + ' ' + timeStr + '\'')
self.led.clock.setPixmap(self.ledClr.yellow)
def btnClkConn(self):
'''
"CONNECT" Button Event Handling. Attempts to connect to SRT Router and Serial
'''
if (self.state.connected):
self.logEvent("ERROR","ALREADY CONNECTED")
else:
# User input --> Port name & baud rate
text = str(self.portMenu.currentText())
text = text.split(' ')
self.port = text[0]
self.baud = int(str(self.baudMenu.currentText()))
if (self.port == "/dev/tty"):
self.logEvent("ERROR","INVALID PORT")
else:
if (self.port == "Wifi"):
try:
# Attempt to connect to router/ethernet over ubiquity
sock.connect(server_address)
self.ser = sock
# Set connected Status true, change LED, log connected status if connected to Ethernet
self.state.connected = True
self.logEvent("CONNECTED",self.port)
self.led.commConn.setPixmap(self.ledClr.yellow)
# must send a command initially for it to stay connected and read data over ethernet.
missionCMD = 'b'
missionCMD = bytes(missionCMD, 'utf-8')
sock.sendall(missionCMD)
# Thread handling
self.serThread = SerThread(self.ser)
self.serThread.outSig.connect(self.outUpdate)
self.serThread.stateSig.connect(self.stateUpdate)
self.serThread.dataSig.connect(self.dataUpdate)
self.serThread.resetSig.connect(self.readFail)
# Test for bypass condition
text = self.ser.recv(100)
if (len(text) > 0):
# Check for empty packet
self.state.reading = True
self.logEvent("READING",self.port)
self.led.commByp.setPixmap(self.ledClr.yellow)
self.serThread.start()
except (TimeoutError, OSError):
self.logEvent("ERROR","INVALID PORT")
else:
try:
# Attempt to connect to serial
self.ser = serial.Serial(self.port,self.baud,timeout=1)
self.state.connected = True
self.logEvent("CONNECTED",self.port)
self.led.commConn.setPixmap(self.ledClr.yellow)
# trying to send a command initially to see if that makes it easy to get connected.
missionCMD = 'b'
missionCMD = bytes(missionCMD, 'utf-8')
self.ser.write(missionCMD)
# Thread handling
self.serThread = SerThread(self.ser)
self.serThread.outSig.connect(self.outUpdate)
self.serThread.stateSig.connect(self.stateUpdate)
self.serThread.dataSig.connect(self.dataUpdate)
self.serThread.resetSig.connect(self.readFail)
# Test for bypass condition
text = self.ser.readline()
if (len(text) > 0):
# Check for empty packet
self.state.reading = True
self.logEvent("READING",self.port)
self.led.commByp.setPixmap(self.ledClr.yellow)
self.serThread.start()
except:
self.logEvent("ERROR","INVALID PORT")
def btnClkByp(self):
# haven't updated bypass method for ubiquity, just Xbee
'''
"BYPASS" Button Event Handling --> XBee (old) firmware quirk
'''
if (self.state.reading):
self.logEvent("ERROR","ALREADY READING")
elif (not self.state.connected):
self.logEvent("ERROR","NO CONNECTION")
else:
# enter, enter, (wait), 'b' --> bypass XBee dongle w/ ascii encoding
self.ser.write(b'\r\n\r\n')
time.sleep(2)
self.ser.write(b'b\r\n')
# Test for bypass condition
text = self.ser.readline()
if (len(text) > 0):
# Check for empty packet
self.state.reading = True
self.logEvent("READING",self.port)
self.led.commByp.setPixmap(self.ledClr.yellow)
self.serThread.start()
def btnClkRes(self):
'''
"RESET" Button Event Handling
'''
if (self.state.connected):
# This is discouraged but thread.quit() and thread.exit() don't work [brute force method]
self.serThread.terminate()
self.state.reading = False
self.led.commByp.setPixmap(self.ledClr.off)
self.ser.close()
self.state.connected = False
self.logEvent("DISCONNECTED",self.port)
self.led.commConn.setPixmap(self.ledClr.off)
# Reset all control status LEDs
ledName = list(self.led.__dict__)
for name in ledName:
if (name == "sess"): # Don't reset session LED
continue
else:
getattr(self.led,name).setPixmap(self.ledClr.off)
else:
self.logEvent("ERROR","NO CONNECTION")
def btnCtrlInit(self):
'''
Control Button Initialization
'''
rSp = 1 # Row span multiplier
cSp = 2 # Column span mutilplier
# Control button specification
# grid, name, text, comm, color, row, col, row span, col span
# System state
btnSpec = [( "gridSys", "sysArm", "SYS ARM", "btnClkCtrl", "sys", 0, 0, 1, 1),
( "gridSys", "sysDisarm", "SYS DISARM", "btnClkCtrl", "sys", 0, 1, 1, 1),
( "gridSys", "ready1", "READY 1", "btnClkCtrl", "abt", 1, 0, 1, 1),
( "gridSys", "ready2", "READY 2", "btnClkCtrl", "abt", 2, 0, 1, 1),
( "gridSys", "abort", "ABORT", "btnClkCtrl", "abt", 1, 1, 2, 1),
( "gridSys", "buzzOn", "BUZZ ON", "btnClkCtrl", "sys", 3, 0, 1, 1),
( "gridSys", "buzzOff", "BUZZ OFF", "btnClkCtrl", "sys", 3, 1, 1, 1),
# Data acquisition
( "gridDaq", "dataState", "DATA STATE", "btnClkCtrl", "daq", 0, 0, 1, 1),
( "gridDaq", "avPwrOff", "AV PWR OFF", "btnClkCtrl", "av", 0, 1, 1, 1),
( "gridDaq", "dataStart", "DATA START", "btnClkCtrl", "daq", 1, 0, 1, 1),
( "gridDaq", "dataStop", "DATA STOP", "btnClkCtrl", "daq", 1, 1, 1, 1),
# Fill control
( "gridFill", "supplyOpen", "SUPPLY OPEN", "btnClkCtrl", "n2o", 0, 0, 1, 1),
( "gridFill", "supplyClose", "SUPPLY CLOSE", "btnClkCtrl", "n2o", 0, 1, 1, 1),
( "gridFill", "supplyVtOpen", "SUPPLY VT OPEN", "btnClkCtrl", "n2o", 1, 0, 1, 1),
( "gridFill", "supplyVtClose", "SUPPLY VT CLOSE", "btnClkCtrl", "n2o", 1, 1, 1, 1),
( "gridFill", "runVtOpen", "RUN VT OPEN", "btnClkCtrl", "n2o", 2, 0, 1, 1),
( "gridFill", "runVtClose", "RUN VT CLOSE", "btnClkCtrl", "n2o", 2, 1, 1, 1),
( "gridFill", "motorOn", "MOTOR ON", "btnClkCtrl", "qd", 3, 0, 1, 1),
( "gridFill", "motorOff", "MOTOR OFF", "btnClkCtrl", "qd", 3, 1, 1, 1),
# Igniter control
( "gridIgn", "ignCont", "IGN CONT", "btnClkCtrl", "ign", 0, 0, 1, 2),
( "gridIgn", "ignArm", "IGN ARM", "btnClkCtrl", "ign", 1, 0, 1, 1),
( "gridIgn", "ignDisarm", "IGN DISARM", "btnClkCtrl", "ign", 1, 1, 1, 1),
( "gridIgn", "oxOpen", "OX OPEN", "btnClkCtrl", "o2", 2, 0, 1, 1),
( "gridIgn", "oxClose", "OX CLOSE", "btnClkCtrl", "o2", 2, 1, 1, 1),
( "gridIgn", "ignOn", "IGN ON", "btnClkCtrl", "ign", 3, 0, 1, 1),
( "gridIgn", "ignOff", "IGN OFF", "btnClkCtrl", "ign", 3, 1, 1, 1),
# Valve control
( "gridVal", "bvPwrOn", "BV PWR ON", "btnClkCtrl", "bvas", 0, 0, 1, 1),
( "gridVal", "bvPwrOff", "BV PWR OFF", "btnClkCtrl", "bvas", 0, 1, 1, 1),
( "gridVal", "bvOpen", "BV OPEN", "btnClkCtrl", "bvas", 1, 0, 1, 1),
( "gridVal", "bvClose", "BV CLOSE", "btnClkCtrl", "bvas", 1, 1, 1, 1),
( "gridVal", "bvState", "BV STATE", "btnClkCtrl", "bvas", 2, 0, 1, 1),
( "gridVal", "mdot", "MDOT", "btnClkCtrl", "mdot", 2, 1, 1, 1)]
for spec in btnSpec:
grid = getattr(self,spec[0])
name = spec[1]
text = spec[2]
method = spec[3]
color = getattr(self.color,spec[4])
row = spec[5]*rSp
col = spec[6]*cSp
rSpan = spec[7]*rSp
cSpan = spec[8]*cSp
# Construct button
btn = self.constr.button(grid,text,method,color,[row,col,rSpan,cSpan])
btn.comm = self.state.btnMap(name) # Find & set character command
btn.led = [] # Create empty list of associated LEDs
# Assign to container
setattr(self.btn,name,btn)
def btnClkCtrl(self):
'''
Control Button Event Handling
'''
sender = self.sender()
self.statusBar.sent.setText(sender.text()) # Update statusbar
self.logEvent(sender.text(),sender.comm)
# Trigger red LED state
if (self.state.connected):
for led in sender.led:
led.setPixmap(self.ledClr.red)
try:
comm = sender.comm.encode("ascii")
try:
self.ser.sendall(comm)
except:
self.ser.write(comm)
except:
if (self.state.connected):
self.logEvent("ERROR","WRITE FAIL")
else:
self.logEvent("ERROR","NO CONNECTION")
def btnClkSessRename(self):
if (self.state.log):
self.session = self.edit.session.text()
self.statusBar.session.setText(self.session)
else:
self.logEvent("ERROR","FILE IO")
def btnClkSessNew(self):
try:
# Close log & data files if initialized
self.closeLog()
# Update session name
self.session = self.edit.session.text()
self.statusBar.session.setText(self.session)
# Generate file date & time stamp(s)
dateLocal = QDate.currentDate()
dateStr = dateLocal.toString(Qt.ISODate)
startLocal = QTime.currentTime()
startStr = startLocal.toString("HH:mm:ss")
# Control & data log initialization
fileObj = ["logFile","dataFile"]
fileDir = ["./log/","./data/"]
fileExt = [".log",".dat"]
for i in range(len(fileObj)):
fileName = dateStr.replace('-','') + '_' + startStr.replace(':','') + fileExt[i]
if (not os.path.exists(fileDir[i])):
os.makedirs(fileDir[i])
setattr(self,fileObj[i],open(fileDir[i] + fileName,'w'))
self.state.log = True
self.led.sess.setPixmap(self.ledClr.yellow)
except:
self.logEvent("ERROR","FILE IO")
def ledCtrlInit(self):
'''
LED Inidicator Initialization
'''
rSp = 1 # Row span multiplier
cSp = 2 # Column span multiplier
# LED indicator specification
# grid, name, row, col, row Span, col Span, buttons ...
# System state
ledSpec = [( "gridSys", "sysArm", 0, 2, 1, 1, "sysArm", "sysDisarm"),
( "gridSys", "ready1", 1, 2, 1, 1, "ready1", "abort"),
( "gridSys", "ready2", 2, 2, 1, 1, "ready2", "abort"),
( "gridSys", "buzz", 3, 2, 1, 1, "buzzOn", "buzzOff"),
# Data acquisition
( "gridDaq", "avPwr", 0, 2, 1, 1, "avPwrOff"),
( "gridDaq", "data", 1, 2, 1, 1, "dataStart", "dataStop", "dataState"),
# Fill control
( "gridFill", "supply", 0, 2, 1, 1, "supplyOpen", "supplyClose"),
( "gridFill", "supplyVt", 1, 2, 1, 1, "supplyVtOpen", "supplyVtClose"),
( "gridFill", "runVt", 2, 2, 1, 1, "runVtOpen", "runVtClose"),
( "gridFill", "motor", 3, 2, 1, 1, "motorOn", "motorOff"),
# Igniter control
( "gridIgn", "ignCont", 0, 2, 1, 1, "ignCont"),
( "gridIgn", "ignArm", 1, 2, 1, 1, "ignArm", "ignDisarm"),
( "gridIgn", "ox", 2, 2, 1, 1, "oxOpen", "oxClose"),
( "gridIgn", "ign", 3, 2, 1, 1, "ignOn", "ignOff"),
# Valve control
( "gridVal", "bvPwr", 0, 2, 1, 1, "bvPwrOn", "bvPwrOff", "bvState", "mdot"),
( "gridVal", "bv", 1, 2, 1, 1, "bvOpen", "bvClose", "bvState", "mdot")]
for spec in ledSpec:
grid = getattr(self,spec[0])
name = spec[1]
row = spec[2]*rSp
col = spec[3]*cSp
rSpan = spec[4]*rSp
cSpan = spec[5]*cSp/2
btn = spec[6:]
# Construct LED
led = self.constr.led(grid,[row,col,rSpan,cSpan])
# Attach LEDs to associated buttons
for btnName in btn:
getattr(self.btn,btnName).led.append(led)
# Assign to container
setattr(self.led,name,led)
def dataInit(self):
'''
Data Array & Sensor Readout Initialization
'''
# Data storage initialization
# time stamp, run tank press, chamber press, run tank temp, chamber temp, aux temp
self.dataTime = 1*60 # Data array length (sec)
self.dataName = ["st","pt","pc","tt","tc","ta"]
self.dataDict = {}
for name in self.dataName:
# looks like it sets dataDict[st], dataDict[pt], ... and so on to none in initialization
setattr(self.data,name,np.array([]))
self.dataDict[name] = None
# Sensor readout specification
# name, text, unit, code, row, col, row span, col span
# Pressure column
sensorSpec = [( "pRun", "Press\nRun", "[ psi ]", "pt", 0, 0, 2, 1, 1),
( "pRun30s", "Extrap\n30 sec", "[ psi ]", "pt", 30, 1, 2, 1, 1),
( "pRun1m", "Extrap\n1 min", "[ psi ]", "pt", 1*60, 2, 2, 1, 1),
( "pRun5m", "Extrap\n5 min", "[ psi ]", "pt", 5*60, 3, 2, 1, 1),
( "pChamb", "Press\nChamb", "[ psi ]", "pc", 0, 4, 2, 1, 1),
# Temperature column
( "tRun", "Temp\nRun", "[ Β°F ]", "tt", 0, 0, 6, 1, 1),
( "tRun30s", "Extrap\n30 sec", "[ Β°F ]", "tt", 30, 1, 6, 1, 1),
( "tRun1m", "Extrap\n1 min", "[ Β°F ]", "tt", 1*60, 2, 6, 1, 1),
( "tRun5m", "Extrap\n5 min", "[ Β°F ]", "tt", 5*60, 3, 6, 1, 1),
( "pRunVap", "Press\nVapor", "[ psi ]", "tt", 0, 4, 6, 1, 1)]
for spec in sensorSpec:
name = spec[0]
text = spec[1]
unit = spec[2]
code = spec[3]
extrap = spec[4]
row = spec[5]
col = spec[6]
rSpan = spec[7]
cSpan = spec[8]
# Construct sensor & assign to container
sensor = self.constr.readout(self.gridPlot,"sensor",[row,col,rSpan,cSpan])
sensor.code = code # Data code
sensor.extrap = extrap # Forward extrapolation time
# Assign to container
setattr(self.sensor,name,sensor)
# Sensor text & unit labels
self.constr.label(self.gridPlot,"label",text,"Center",[row,col-1,1,1])
self.constr.label(self.gridPlot,"label",unit,"Center",[row,col+1,1,1])
# Generate sensor list
self.sensorName = list(self.sensor.__dict__)
# Row & column stretching in plotGrid
rowStr = []
colStr = [8, 1, 1, 1, 8, 1, 1, 1]
self.tools.resize(self.gridPlot,rowStr,colStr)
def plotInit(self):
'''
Live Plot Initialization
'''
self.plot = [None] * 2
# Pressure plot
yRange = [0,950]
xLabel = ["Time","sec"]
yLabel = ["Run Tank Pressure","psi"]
hour = [1,2,3,4,5,6,7,8,9,10]
temperature = [400,432,434,432,433,431,429,432,435,445]
self.plot[0] = self.constr.plot(self.gridPlot,yRange,xLabel,yLabel,[0,0,5,1])
self.plotPress = self.plot[0].plot()
# Temperature plot
yRange = [0,150]
xLabel = ["Time","sec"]
yLabel = ["Run Tank Temperature","Β°F"]
hour = [1,2,3,4,5,6,7,8,9,10]
temperature = [100,90,80,90,90,90,100,100,100,100]
self.plot[1] = self.constr.plot(self.gridPlot,yRange,xLabel,yLabel,[0,4,5,1])
self.plotTemp = self.plot[1].plot()
def outInit(self):
# Create scroll box for raw serial output
self.serialOut = self.constr.scrollBox(self.gridOut,[0,0,1,1])
def outUpdate(self,text):
self.serialOut.moveCursor(QtGui.QTextCursor.End)
self.serialOut.insertPlainText(text + "\n")
sb = self.serialOut.verticalScrollBar()
sb.setValue(sb.maximum())
def stateUpdate(self,text):
'''
Control State Update
'''
# Update statusbar
self.statusBar.recieved.setText(text)
try:
# Logs state event, update state object, update PID graphic (eventually)
self.logEvent("STATE",text)
# QUICK FIX FOR ABORT STATE
if (text == "xLBabo"):
self.state.update("xLBrl10")
self.state.update("xLBrl20")
else:
self.state.update(text)
except:
self.logEvent("ERROR","STATE FAIL")
def dataUpdate(self,text):
print("gets here, right?")
'''
Plot & Sensor Update
'''
try:
# Write to data log
if self.state.log:
self.dataFile.write(text + '\n')
print("writing")
# Process data packet
raw = text.split(',')
nEnd = len(self.data.st)
print(raw, nEnd)
# Update dictionary --> maps code to reading
for field in raw:
self.dataDict[field[0:2]] = field[2:]
# Convert time stamps to elapsed from AV start (first packet)
if (self.state.data):
stamp = self.dataDict["st"]
nowData = datetime.strptime(stamp,"%H:%M:%S.%f")
delta = nowData - self.startData
elapsed = delta.total_seconds()
self.dataDict["st"] = elapsed
else:
stamp = self.dataDict["st"]
self.startData = datetime.strptime(stamp,"%H:%M:%S.%f")
self.state.data = True
self.dataDict["st"] = 0
# Establish extrapolation time step
if (len(self.data.st) < 2):
step = 1 # Arbitrary value; can't be zero
else:
step = self.data.st[-1] - self.data.st[-2]
nData = np.floor(self.dataTime/step)
# Populate data arrays: after filling array, delete first element & append to end
if (nEnd < nData): # Case: array not full
for name in self.dataName:
value = float(self.dataDict[name])
setattr(self.data,name,np.append(getattr(self.data,name),value))
else: # Case: array full
for name in self.dataName:
value = float(self.dataDict[name])
getattr(self.data,name,np.roll(getattr(self.data,name),-1))
getattr(self.data,name)[-1] = value
# Sensor readout update
for name in self.sensorName:
sensor = getattr(self.sensor,name)
data = getattr(self.data,sensor.code)
value = self.tools.extrap(self.data.st,data,sensor.extrap,step)
if (name == "pRunVap"): # Vapor pressure from run tank temp
value = self.tools.vapPress(value)
sensor.setText(str(round(value,2)))
# Live plot update
#xTime = self.data.st - self.data.st[-1] # Center time scale at present reading
xTime = [1,2,3,4,5,6,7,8,9,10]
yPress = [400,432,434,432,433,431,429,432,435,445]
print(xTime)
print("YPress:")
print(yPress)
#yPress = self.data.pt # Tank pressure array
yTemp = self.data.tt # Tank temperature array
print("yTemp:")
print(yTemp)
self.plotPress.setData(xTime,yPress,pen=self.style.pen.press)
self.plotTemp.setData(xTime,yTemp,pen=self.style.pen.temp)
except:
# Throws error if failure to read data packet
self.logEvent("ERROR","DAQ FAIL")
if (self.state.log):
self.dataFile.write("ERROR: " + text + '\n')
def readFail(self,text):
'''
Log Read Fail & Reset Connection
'''
self.btnClkRes()
self.logEvent("ERROR",text)
def logEvent(self,event,text):
'''
Log Event Management
'''
# Build, print stamp to statusbar & log
now = QTime.currentTime()
stamp = now.toString("HH:mm:ss.zzz")
pad = ' ' * 5
# Print to statusbar, format if necessary
self.statusBar.log.setText(stamp + pad + event + pad + "\"" + text + "\"")
if (event == "ERROR"):
self.statusBar.log.setStyleSheet(self.style.css.error)
else:
self.statusBar.log.setStyleSheet(self.style.css.statusBar)
# Print to log file
if (self.state.log):
self.logFile.write(stamp + ", " + event + ", " + "\"" + text + "\"" + "\n")
def closeLog(self):
'''
File Close Management
'''
if (self.state.log):
self.state.log = False # Protects thread issues; writing to closed file
fileObj = ["logFile","dataFile"]
for logName in fileObj:
# Close & rename file(s)
filePath = getattr(self,logName).name.split('/')
filePath[2] = self.session + '_' + filePath[2]
filePath = '/'.join(filePath)
getattr(self,logName).close()
os.rename(getattr(self,logName).name,filePath)
def closeEvent(self,event):
'''
GUI Exit Management
'''
# Close log & data files if initialized
self.closeLog()
# Exit GUI safely
event.accept()
if (__name__ == '__main__'):
'''
Executive Control
'''
app = QApplication(sys.argv) # Utility for window exit condition
gui = Gui() # Creates instance of "Gui" class
sys.exit(app.exec_()) # Window exit condition |
The product of $0$ and $b$ is $0$. |
%% quiverTriad
% Below is a demonstration of the features of the |quiverTriad| function
%%
clear; close all; clc;
%% Syntax
% |[varargout]=quiverTriad(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/>.
|
-- this is the first test I run
-- Its been a while since i used my brain, @KMx404
module test1 where
data π : Set where
--zero : π --its not practical to do so, we can use more efficient math formulas
suc : π β π -- since We have the value of zero => n, any next item succ will consider it as n.num
_+_ : π β π β π -- Defining addition? I guess (wtf is guess? haha)
-- zero : zero
--zero + zero = zero
--zero + π = π -- Zero has no effect in addition
|
(* Title: HOL/Probability/Discrete_Topology.thy
Author: Fabian Immler, TU MΓΌnchen
*)
theory Discrete_Topology
imports "HOL-Analysis.Analysis"
begin
text \<open>Copy of discrete types with discrete topology. This space is polish.\<close>
typedef 'a discrete = "UNIV::'a set"
morphisms of_discrete discrete
..
instantiation discrete :: (type) metric_space
begin
definition dist_discrete :: "'a discrete \<Rightarrow> 'a discrete \<Rightarrow> real"
where "dist_discrete n m = (if n = m then 0 else 1)"
definition uniformity_discrete :: "('a discrete \<times> 'a discrete) filter" where
"(uniformity::('a discrete \<times> 'a discrete) filter) = (INF e\<in>{0 <..}. principal {(x, y). dist x y < e})"
definition "open_discrete" :: "'a discrete set \<Rightarrow> bool" where
"(open::'a discrete set \<Rightarrow> bool) U \<longleftrightarrow> (\<forall>x\<in>U. eventually (\<lambda>(x', y). x' = x \<longrightarrow> y \<in> U) uniformity)"
instance proof qed (auto simp: uniformity_discrete_def open_discrete_def dist_discrete_def intro: exI[where x=1])
end
lemma open_discrete: "open (S :: 'a discrete set)"
unfolding open_dist dist_discrete_def by (auto intro!: exI[of _ "1 / 2"])
instance discrete :: (type) complete_space
proof
fix X::"nat\<Rightarrow>'a discrete"
assume "Cauchy X"
then obtain n where "\<forall>m\<ge>n. X n = X m"
by (force simp: dist_discrete_def Cauchy_def split: if_split_asm dest:spec[where x=1])
thus "convergent X"
by (intro convergentI[where L="X n"] tendstoI eventually_sequentiallyI[of n])
(simp add: dist_discrete_def)
qed
instance discrete :: (countable) countable
proof
have "inj (\<lambda>c::'a discrete. to_nat (of_discrete c))"
by (simp add: inj_on_def of_discrete_inject)
thus "\<exists>f::'a discrete \<Rightarrow> nat. inj f" by blast
qed
instance discrete :: (countable) second_countable_topology
proof
let ?B = "range (\<lambda>n::'a discrete. {n})"
have "\<And>S. generate_topology ?B (\<Union>x\<in>S. {x})"
by (intro generate_topology_Union) (auto intro: generate_topology.intros)
then have "open = generate_topology ?B"
by (auto intro!: ext simp: open_discrete)
moreover have "countable ?B" by simp
ultimately show "\<exists>B::'a discrete set set. countable B \<and> open = generate_topology B" by blast
qed
instance discrete :: (countable) polish_space ..
end
|
/-
Copyright (c) 2016 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Leonardo de Moura
-/
import Mathlib.PrePort
import Mathlib.Lean3Lib.init.logic
import Mathlib.Lean3Lib.init.data.nat.basic
import Mathlib.Lean3Lib.init.data.bool.basic
import Mathlib.Lean3Lib.init.propext
universes u u_1 v w
namespace Mathlib
protected instance list.inhabited (Ξ± : Type u) : Inhabited (List Ξ±) :=
{ default := [] }
namespace list
protected def has_dec_eq {Ξ± : Type u} [s : DecidableEq Ξ±] : DecidableEq (List Ξ±) :=
sorry
protected instance decidable_eq {Ξ± : Type u} [DecidableEq Ξ±] : DecidableEq (List Ξ±) :=
list.has_dec_eq
@[simp] protected def append {Ξ± : Type u} : List Ξ± β List Ξ± β List Ξ± :=
sorry
protected instance has_append {Ξ± : Type u} : Append (List Ξ±) :=
{ append := list.append }
protected def mem {Ξ± : Type u} : Ξ± β List Ξ± β Prop :=
sorry
protected instance has_mem {Ξ± : Type u} : has_mem Ξ± (List Ξ±) :=
has_mem.mk list.mem
protected instance decidable_mem {Ξ± : Type u} [DecidableEq Ξ±] (a : Ξ±) (l : List Ξ±) : Decidable (a β l) :=
sorry
protected instance has_emptyc {Ξ± : Type u} : has_emptyc (List Ξ±) :=
has_emptyc.mk []
protected def erase {Ξ± : Type u_1} [DecidableEq Ξ±] : List Ξ± β Ξ± β List Ξ± :=
sorry
protected def bag_inter {Ξ± : Type u_1} [DecidableEq Ξ±] : List Ξ± β List Ξ± β List Ξ± :=
sorry
protected def diff {Ξ± : Type u_1} [DecidableEq Ξ±] : List Ξ± β List Ξ± β List Ξ± :=
sorry
@[simp] def length {Ξ± : Type u} : List Ξ± β β :=
sorry
def empty {Ξ± : Type u} : List Ξ± β Bool :=
sorry
@[simp] def nth {Ξ± : Type u} : List Ξ± β β β Option Ξ± :=
sorry
@[simp] def nth_le {Ξ± : Type u} (l : List Ξ±) (n : β) : n < length l β Ξ± :=
sorry
@[simp] def head {Ξ± : Type u} [Inhabited Ξ±] : List Ξ± β Ξ± :=
sorry
@[simp] def tail {Ξ± : Type u} : List Ξ± β List Ξ± :=
sorry
def reverse_core {Ξ± : Type u} : List Ξ± β List Ξ± β List Ξ± :=
sorry
def reverse {Ξ± : Type u} : List Ξ± β List Ξ± :=
fun (l : List Ξ±) => reverse_core l []
@[simp] def map {Ξ± : Type u} {Ξ² : Type v} (f : Ξ± β Ξ²) : List Ξ± β List Ξ² :=
sorry
@[simp] def mapβ {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w} (f : Ξ± β Ξ² β Ξ³) : List Ξ± β List Ξ² β List Ξ³ :=
sorry
def map_with_index_core {Ξ± : Type u} {Ξ² : Type v} (f : β β Ξ± β Ξ²) : β β List Ξ± β List Ξ² :=
sorry
/-- Given a function `f : β β Ξ± β Ξ²` and `as : list Ξ±`, `as = [aβ, aβ, ...]`, returns the list
`[f 0 aβ, f 1 aβ, ...]`. -/
def map_with_index {Ξ± : Type u} {Ξ² : Type v} (f : β β Ξ± β Ξ²) (as : List Ξ±) : List Ξ² :=
map_with_index_core f 0 as
def join {Ξ± : Type u} : List (List Ξ±) β List Ξ± :=
sorry
def filter_map {Ξ± : Type u} {Ξ² : Type v} (f : Ξ± β Option Ξ²) : List Ξ± β List Ξ² :=
sorry
def filter {Ξ± : Type u} (p : Ξ± β Prop) [decidable_pred p] : List Ξ± β List Ξ± :=
sorry
def partition {Ξ± : Type u} (p : Ξ± β Prop) [decidable_pred p] : List Ξ± β List Ξ± Γ List Ξ± :=
sorry
def drop_while {Ξ± : Type u} (p : Ξ± β Prop) [decidable_pred p] : List Ξ± β List Ξ± :=
sorry
/-- `after p xs` is the suffix of `xs` after the first element that satisfies
`p`, not including that element.
```lean
after (eq 1) [0, 1, 2, 3] = [2, 3]
drop_while (not β eq 1) [0, 1, 2, 3] = [1, 2, 3]
```
-/
def after {Ξ± : Type u} (p : Ξ± β Prop) [decidable_pred p] : List Ξ± β List Ξ± :=
sorry
def span {Ξ± : Type u} (p : Ξ± β Prop) [decidable_pred p] : List Ξ± β List Ξ± Γ List Ξ± :=
sorry
def find_index {Ξ± : Type u} (p : Ξ± β Prop) [decidable_pred p] : List Ξ± β β :=
sorry
def index_of {Ξ± : Type u} [DecidableEq Ξ±] (a : Ξ±) : List Ξ± β β :=
find_index (Eq a)
def remove_all {Ξ± : Type u} [DecidableEq Ξ±] (xs : List Ξ±) (ys : List Ξ±) : List Ξ± :=
filter (fun (_x : Ξ±) => Β¬_x β ys) xs
def update_nth {Ξ± : Type u} : List Ξ± β β β Ξ± β List Ξ± :=
sorry
def remove_nth {Ξ± : Type u} : List Ξ± β β β List Ξ± :=
sorry
@[simp] def drop {Ξ± : Type u} : β β List Ξ± β List Ξ± :=
sorry
@[simp] def take {Ξ± : Type u} : β β List Ξ± β List Ξ± :=
sorry
@[simp] def foldl {Ξ± : Type u} {Ξ² : Type v} (f : Ξ± β Ξ² β Ξ±) : Ξ± β List Ξ² β Ξ± :=
sorry
@[simp] def foldr {Ξ± : Type u} {Ξ² : Type v} (f : Ξ± β Ξ² β Ξ²) (b : Ξ²) : List Ξ± β Ξ² :=
sorry
def any {Ξ± : Type u} (l : List Ξ±) (p : Ξ± β Bool) : Bool :=
foldr (fun (a : Ξ±) (r : Bool) => p a || r) false l
def all {Ξ± : Type u} (l : List Ξ±) (p : Ξ± β Bool) : Bool :=
foldr (fun (a : Ξ±) (r : Bool) => p a && r) tt l
def bor (l : List Bool) : Bool :=
any l id
def band (l : List Bool) : Bool :=
all l id
def zip_with {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w} (f : Ξ± β Ξ² β Ξ³) : List Ξ± β List Ξ² β List Ξ³ :=
sorry
def zip {Ξ± : Type u} {Ξ² : Type v} : List Ξ± β List Ξ² β List (Ξ± Γ Ξ²) :=
zip_with Prod.mk
def unzip {Ξ± : Type u} {Ξ² : Type v} : List (Ξ± Γ Ξ²) β List Ξ± Γ List Ξ² :=
sorry
protected def insert {Ξ± : Type u} [DecidableEq Ξ±] (a : Ξ±) (l : List Ξ±) : List Ξ± :=
ite (a β l) l (a :: l)
protected instance has_insert {Ξ± : Type u} [DecidableEq Ξ±] : has_insert Ξ± (List Ξ±) :=
has_insert.mk list.insert
protected instance has_singleton {Ξ± : Type u} : has_singleton Ξ± (List Ξ±) :=
has_singleton.mk fun (x : Ξ±) => [x]
protected instance is_lawful_singleton {Ξ± : Type u} [DecidableEq Ξ±] : is_lawful_singleton Ξ± (List Ξ±) :=
is_lawful_singleton.mk fun (x : Ξ±) => (fun (this : ite (x β []) [] [x] = [x]) => this) (if_neg not_false)
protected def union {Ξ± : Type u} [DecidableEq Ξ±] (lβ : List Ξ±) (lβ : List Ξ±) : List Ξ± :=
foldr insert lβ lβ
protected instance has_union {Ξ± : Type u} [DecidableEq Ξ±] : has_union (List Ξ±) :=
has_union.mk list.union
protected def inter {Ξ± : Type u} [DecidableEq Ξ±] (lβ : List Ξ±) (lβ : List Ξ±) : List Ξ± :=
filter (fun (_x : Ξ±) => _x β lβ) lβ
protected instance has_inter {Ξ± : Type u} [DecidableEq Ξ±] : has_inter (List Ξ±) :=
has_inter.mk list.inter
@[simp] def repeat {Ξ± : Type u} (a : Ξ±) : β β List Ξ± :=
sorry
def range_core : β β List β β List β :=
sorry
def range (n : β) : List β :=
range_core n []
def iota : β β List β :=
sorry
def enum_from {Ξ± : Type u} : β β List Ξ± β List (β Γ Ξ±) :=
sorry
def enum {Ξ± : Type u} : List Ξ± β List (β Γ Ξ±) :=
enum_from 0
@[simp] def last {Ξ± : Type u} (l : List Ξ±) : l β [] β Ξ± :=
sorry
def ilast {Ξ± : Type u} [Inhabited Ξ±] : List Ξ± β Ξ± :=
sorry
def init {Ξ± : Type u} : List Ξ± β List Ξ± :=
sorry
def intersperse {Ξ± : Type u} (sep : Ξ±) : List Ξ± β List Ξ± :=
sorry
def intercalate {Ξ± : Type u} (sep : List Ξ±) (xs : List (List Ξ±)) : List Ξ± :=
join (intersperse sep xs)
protected def bind {Ξ± : Type u} {Ξ² : Type v} (a : List Ξ±) (b : Ξ± β List Ξ²) : List Ξ² :=
join (map b a)
protected def ret {Ξ± : Type u} (a : Ξ±) : List Ξ± :=
[a]
protected def lt {Ξ± : Type u} [HasLess Ξ±] : List Ξ± β List Ξ± β Prop :=
sorry
protected instance has_lt {Ξ± : Type u} [HasLess Ξ±] : HasLess (List Ξ±) :=
{ Less := list.lt }
protected instance has_decidable_lt {Ξ± : Type u} [HasLess Ξ±] [h : DecidableRel Less] (lβ : List Ξ±) (lβ : List Ξ±) : Decidable (lβ < lβ) :=
sorry
protected def le {Ξ± : Type u} [HasLess Ξ±] (a : List Ξ±) (b : List Ξ±) :=
Β¬b < a
protected instance has_le {Ξ± : Type u} [HasLess Ξ±] : HasLessEq (List Ξ±) :=
{ LessEq := list.le }
protected instance has_decidable_le {Ξ± : Type u} [HasLess Ξ±] [h : DecidableRel Less] (lβ : List Ξ±) (lβ : List Ξ±) : Decidable (lβ β€ lβ) :=
not.decidable
theorem le_eq_not_gt {Ξ± : Type u} [HasLess Ξ±] (lβ : List Ξ±) (lβ : List Ξ±) : lβ β€ lβ = (Β¬lβ < lβ) :=
rfl
theorem lt_eq_not_ge {Ξ± : Type u} [HasLess Ξ±] [DecidableRel Less] (lβ : List Ξ±) (lβ : List Ξ±) : lβ < lβ = (Β¬lβ β€ lβ) :=
(fun (this : lβ < lβ = (¬¬lβ < lβ)) => this) (Eq.symm (propext (decidable.not_not_iff (lβ < lβ))) βΈ rfl)
/-- `is_prefix_of lβ lβ` returns `tt` iff `lβ` is a prefix of `lβ`. -/
def is_prefix_of {Ξ± : Type u} [DecidableEq Ξ±] : List Ξ± β List Ξ± β Bool :=
sorry
/-- `is_suffix_of lβ lβ` returns `tt` iff `lβ` is a suffix of `lβ`. -/
def is_suffix_of {Ξ± : Type u} [DecidableEq Ξ±] (lβ : List Ξ±) (lβ : List Ξ±) : Bool :=
is_prefix_of (reverse lβ) (reverse lβ)
end list
namespace bin_tree
def to_list {Ξ± : Type u} (t : bin_tree Ξ±) : List Ξ± :=
to_list_aux t []
|
module Issue833
import Data.Fin
%default total
data Singleton : Nat -> Type where
Sing : {n : Nat} -> Singleton n
f : (n : Singleton Z) -> n === Sing
f = \ Sing => Refl
g : (k : Fin 1) -> k === FZ
g = \ FZ => Refl
sym : {t, u : a} -> t === u -> u === t
sym = \Refl => Refl
|
from os import listdir
from os.path import isfile, join
import rosbag
import numpy as np
from scipy.signal import savgol_filter
# OPTION ROBOTIQUE 2021-2022 PROJET INTEG -IDENTIFICATION- N.FRAPPEREAU & J.DELACOUX
# In this file you'll find the script we used to pre-process data for our training algorithm
# The data has already been "collected" and is inside .bag files in the /dataset folder.
# We need to extract that data and put it in a format usable by our training algorithm - we chose np.arrays
# This function lists the files in the /dataset folder, reads them, extracts the data from them and put it in a np.array
# When this is done for a .bag file, we close it and go to the next one in the /dataset folder, until there aren't any .bag file left
def pre_process():
# ~ Number of columns of the final data file: - 8 columns for the input of our neural network : (theta1, omega1, effort1, acceleration1, theta2, omega2, effort2, acceleration2)
# ~ - 6 columns for the desired output of our neural network : (I1, I2, m1, m2, com1, com2)
dim = 14
# ~ List all files in the dataset folder
bag_list = [f for f in listdir('dataset/') if isfile(join('dataset/', f))]
# ~ Definition of the overall data array which is the concatenation of the arrays of data extracted from each .bag file
data = np.zeros((0,dim))
for bag_file in bag_list:
# ~ Read a bag file from the list of files
bag = rosbag.Bag('dataset/'+bag_file)
# ~ Extracts the parameter values from the bag name and saves them in a np.array
parameters = bag_file.split('-')
parameters[-1] = parameters[-1][:-4]
parameters = [float(parameter) for parameter in parameters]
parameters = np.array(parameters)
# ~ Declares the data array from this SPECIFIC bag file
input_data = np.zeros((0,dim))
# ~ Extracting data from bag file, appending the parameter values at the end of each line
for topic, msg, t in bag.read_messages(topics=['/joint_states']):
new_line = np.array([msg.position[0],msg.velocity[0],msg.effort[0],0,msg.position[1],msg.velocity[1],msg.effort[1],0])
new_line = np.append(new_line, parameters, 0)
input_data = np.vstack((input_data, new_line.reshape(1,dim)))
# ~ Calculating accelerations of both links using a Savitzky-Golay filter of the 3rd order with a window size of 5 applied to the speed data
input_data[:,3] = savgol_filter(input_data[:,1], 5, 3, deriv=1, delta=0.1)
input_data[:,7] = savgol_filter(input_data[:,5], 5, 3, deriv=1, delta=0.1)
# ~ Removing values around mechanical stops
index = 0
while index < len(input_data):
if abs(input_data[index][0])>3.0 or abs(input_data[index][4])>3.0:
input_data = np.delete(input_data, index, 0)
else :
index += 1
# ~ Remove first and last 3 lines because the Savitzky-Golay derivative of the speed is not well defined there
input_data = input_data[3:-3]
# ~ Add the current bag's data to the global data array
data = np.vstack((data, input_data))
# ~ Close .bag file
bag.close()
return data
|
-- Doble_del_producto_menor_que_suma_de_cuadrados.lean
-- Si a, b β β, entonces 2ab β€ aΒ² + bΒ²
-- JosΓ© A. Alonso JimΓ©nez <https://jaalonso.github.io>
-- Sevilla, 27-septiembre-2022
-- ---------------------------------------------------------------------
-- ---------------------------------------------------------------------
-- Demostrar que si a, b β β, entonces 2ab β€ aΒ² + bΒ².
-- ---------------------------------------------------------------------
import data.real.basic
import tactic
variables a b : β
-- 1Βͺ demostraciΓ³n
example : 2*a*b β€ a^2 + b^2 :=
begin
have : 0 β€ (a - b)^2 := sq_nonneg (a - b),
have : 0 β€ a^2 - 2*a*b + b^2, by linarith,
show 2*a*b β€ a^2 + b^2, by linarith,
end
-- 2Βͺ demostraciΓ³n
example : 2*a*b β€ a^2 + b^2 :=
begin
have h : 0 β€ a^2 - 2*a*b + b^2,
{ calc a^2 - 2*a*b + b^2
= (a - b)^2 : by ring
... β₯ 0 : by apply pow_two_nonneg },
calc 2*a*b
= 2*a*b + 0 : by ring
... β€ 2*a*b + (a^2 - 2*a*b + b^2) : add_le_add (le_refl _) h
... = a^2 + b^2 : by ring
end
-- 3Βͺ demostraciΓ³n
example : 2*a*b β€ a^2 + b^2 :=
begin
have : 0 β€ a^2 - 2*a*b + b^2,
{ calc a^2 - 2*a*b + b^2
= (a - b)^2 : by ring
... β₯ 0 : by apply pow_two_nonneg },
linarith,
end
-- 4Βͺ demostraciΓ³n
example : 2*a*b β€ a^2 + b^2 :=
-- by library_search
two_mul_le_add_sq a b
|
function [mu, sigma, sigma_points] = prediction_step(mu, sigma, u)
% Updates the belief concerning the robot pose according to the motion model.
% mu: state vector containing robot pose and poses of landmarks obeserved so far
% Current robot pose = mu(1:3)
% Note that the landmark poses in mu are stacked in the order by which they were observed
% sigma: the covariance matrix of the system.
% u: odometry reading (r1, t, r2)
% Use u.r1, u.t, and u.r2 to access the rotation and translation values
% For computing lambda.
global scale;
% Compute sigma points
sigma_points = compute_sigma_points(mu, sigma);
% Dimensionality
n = length(mu);
% lambda
lambda = scale - n;
% TODO: Transform all sigma points according to the odometry command
% Remember to vectorize your operations and normalize angles
% Tip: the function normalize_angle also works on a vector (row) of angles
for i=1:2*n+1
sigma_points(1:3,i) = sigma_points(1:3,i) + [u.t*cos(sigma_points(3,i) + u.r1); u.t*sin(sigma_points(3,i) + u.r1); u.r1 + u.r2];
sigma_points(3,i) = normalize_angle(sigma_points(3,i));
endfor
% Computing the weights for recovering the mean
wm = [lambda/scale, repmat(1/(2*scale),1,2*n)];
wc = wm;
% -------- My initialization ----------- %
xbar = 0;
ybar = 0;
mu = zeros(n,1);
sigma = zeros(n);
% TODO: recover mu.
% Be careful when computing the robot's orientation (sum up the sines and
% cosines and recover the 'average' angle via atan2)
for i=1:2*n+1
mu = mu + wm(i)*sigma_points(:,i);
xbar = xbar + wm(i)*cos(sigma_points(3,i));
ybar = ybar + wm(i)*sin(sigma_points(3,i));
endfor
mu(3) = atan2(ybar,xbar);
mu(3) = normalize_angle(mu(3));
% TODO: Recover sigma. Again, normalize the angular difference
for i=1:2*n+1
tmp = sigma_points(:,i) - mu;
tmp(3) = normalize_angle(tmp(3));
sigma = sigma + wc(i)*tmp*tmp';
endfor
% Motion noise
motionNoise = 0.1;
R3 = [motionNoise, 0, 0;
0, motionNoise, 0;
0, 0, motionNoise/10];
R = zeros(size(sigma,1));
R(1:3,1:3) = R3;
% TODO: Add motion noise to sigma
sigma = sigma + R;
end
|
# Scenario D - Peakshape Variation (results evaluation)
This file is used to evaluate the inference (numerical) results.
The model used in the inference of the parameters is formulated as follows:
\begin{equation}
\large y = f(x) = \sum\limits_{m=1}^M \big[A_m \cdot f_{pseudo-Voigt}(x)\big] + \epsilon
\end{equation}
where:
\begin{equation}
\large f_{pseudo-Voigt}(x) = \eta \cdot \frac{\sigma_m^2}{(x-\mu_m)^2 + \sigma_m^2} + (1 - \eta) \cdot e^{-\frac{(x-\mu_m)^2}{2\cdot\sigma_m^2}}
\end{equation}
```python
%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import pymc3 as pm
import arviz as az
import seaborn as sns
#az.style.use('arviz-darkgrid')
print('Running on PyMC3 v{}'.format(pm.__version__))
```
WARNING (theano.tensor.blas): Using NumPy C-API based implementation for BLAS functions.
Running on PyMC3 v3.8
## Import local modules
```python
import sys
sys.path.append('../../modules')
import results as res
import figures as fig
```
## Load results and extract convergence information
```python
# list of result files to load
filelst = ['./scenario_peakshape_mruns.csv']
ldf = res.load_results(filelst)
```
reading file: ./scenario_peakshape_mruns.csv
```python
# extract the convergence results per model
labellist = [0.0, 0.25, 0.5, 0.75, 1.0]
dres = res.get_model_summary(ldf, labellist)
```
```python
# figure size and color mapping
figs=(8,8)
col = "Blues"
col_r = col + "_r"
```
## Heatmaps of n-peak model vs. n-peak number in dataset
### WAIC
```python
fig.plot_heatmap(dres['waic'], labellist, title="", color=col, fsize=figs, fname="hmap_waic", precision=".0f")
```
### Rhat
```python
fig.plot_heatmap(dres['rhat'], labellist, title="", color=col, fsize=figs, fname="hmap_rhat", precision=".2f")
```
### R2
```python
fig.plot_heatmap(dres['r2'], labellist, title="", color=col_r, fsize=figs, fname="hmap_r2", precision=".2f")
```
### BFMI
```python
fig.plot_heatmap(dres['bfmi'], labellist, title="", color=col_r, fsize=figs,
fname="hmap_bfmi", precision=".2f")
```
### MCSE
```python
fig.plot_heatmap(dres['mcse'], labellist, title="", color=col, fsize=figs, fname="hmap_mcse", precision=".2f")
```
### Noise
```python
fig.plot_heatmap(dres['noise'], labellist, title="", color=col, fsize=figs,
fname="hmap_noise", precision=".2f")
```
### ESS
```python
fig.plot_heatmap(dres['ess'], labellist, title="", color=col_r, fsize=figs, fname="hmap_ess", precision=".0f")
```
```python
```
|
C
C $Id: gwid2r.f,v 1.4 2008-07-27 00:21:07 haley Exp $
C
C Copyright (C) 2000
C University Corporation for Atmospheric Research
C All Rights Reserved
C
C The use of this Software is governed by a License Agreement.
C
SUBROUTINE GWID2R
C
C Copy "DEFAULT" attribute context to "REQUESTED" context.
C
include 'gwiarq.h'
include 'gwiadf.h'
C
INTEGER I
C
SAVE
C
C Polyline attributes.
C
MRPLIX = MDPLIX
MRLTYP = MDLTYP
ARLWSC = ADLWSC
MRPLCI = MDPLCI
C
C Polymarker attributes.
C
MRPMIX = MDPMIX
MRMTYP = MDMTYP
ARMSZS = ADMSZS
MRPMCI = MDPMCI
C
C Text attributes.
C
MRTXIX = MDTXIX
MRTXP = MDTXP
MRTXAL(1) = MDTXAL(1)
MRTXAL(2) = MDTXAL(2)
MRCHH = MDCHH
DO 10 I=1,4
MRCHOV(I) = MDCHOV(I)
10 CONTINUE
MRTXFO = MDTXFO
MRTXPR = MDTXPR
ARCHXP = ADCHXP
ARCHSP = ADCHSP
MRTXCI = MDTXCI
C
C Fill area attributes.
C
MRFAIX = MDFAIX
MRPASZ(1) = MDPASZ(1)
MRPASZ(2) = MDPASZ(2)
MRPASZ(3) = MDPASZ(3)
MRPASZ(4) = MDPASZ(4)
MRPARF(1) = MDPARF(1)
MRPARF(2) = MDPARF(2)
MRFAIS = MDFAIS
MRFASI = MDFASI
MRFACI = MDFACI
C
C Aspect source flags.
C
DO 20 I=1,13
MRASF(I) = MDASF(I)
20 CONTINUE
C
RETURN
END
|
Formal statement is: corollary contractible_sphere: fixes a :: "'a::euclidean_space" shows "contractible(sphere a r) \<longleftrightarrow> r \<le> 0" Informal statement is: The sphere of radius $r$ is contractible if and only if $r \leq 0$. |
%%%%%%%%%%%%%%%%%%%%%%% file template.tex %%%%%%%%%%%%%%%%%%%%%%%%%
%
% This is a general template file for the LaTeX package SVJour3
% for Springer journals. Springer Heidelberg 2010/09/16
%
% Copy it to a new file with a new name and use it as the basis
% for your article. Delete % signs as needed.
%
% This template includes a few options for different layouts and
% content for various journals. Please consult a previous issue of
% your journal as needed.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% First comes an example EPS file -- just ignore it and
% proceed on the \documentclass line
% your LaTeX will extract the file if required
%
\RequirePackage{fix-cm}
%
%\documentclass{svjour3} % onecolumn (standard format)
%\documentclass[smallcondensed]{svjour3} % onecolumn (ditto)
\documentclass[smallextended]{svjour3} % onecolumn (second format)
%\documentclass[twocolumn]{svjour3} % twocolumn
%
\smartqed % flush right qed marks, e.g. at end of proof
%
\usepackage{amsmath}
\usepackage{booktabs}
\usepackage{subcaption}
\usepackage{tabularx}
\usepackage{nicefrac}
\usepackage[usenames]{xcolor}
\usepackage{lineno,hyperref}
\usepackage{graphicx}
%
% \usepackage{mathptmx} % use Times fonts if available on your TeX system
%
% insert here the call for the packages your document requires
%\usepackage{latexsym}
% etc.
%
% please place your own definitions here and don't use \def but
% \newcommand{}{}
%
% Insert the name of "your journal" with
% \journalname{myjournal}
%
\begin{document}
\title{Interaction effects on the Energy Release Rate of debonds in the fracture plane precursor in UD composites under transverse tension}
%\subtitle{}
%\titlerunning{Short form of title} % if too long for running head
\author{Luca Di Stasio \and
Janis Varna
}
%\authorrunning{Short form of author list} % if too long for running head
\institute{Luca Di Stasio \at
Continuum \& Computational Mechanics of Materials (C2M2) Group\\Division of Physical Sciences and Engineering\\King Abdullah University of Science and Technology (KAUST)\\Thuwal, 23955-6900\\Kingdom of Saudi Arabia\\
\email{[email protected]} % \\
% \emph{Present address:} of F. Author % if needed
\and
Janis Varna \at
Lule\aa\ University of Technology, University Campus, SE-97187 Lule\aa, Sweden\\
\email{[email protected]}
}
\date{Received: date / Accepted: date}
% The correct dates will be entered by the editor
\maketitle
\begin{abstract}
In a UD composite under transverse tensile loading, an increasing number of fiber/matrix interface cracks (or debonds) appears localized in the regions where transverse failure (in the form of transverse cracks) will occur. Models of Representative Volume Elements (RVEs) of UD composites are developed to study the interaction between debonds in this stage of transverse crack onset, that precedes the appearance of a through-the-thickness crack through crack-kinking into the matrix. Several damage states are studied in the form of different geometrical configurations of partially debonded and fully bonded fibers. It is found that, when the vertically aligned partially debonded fibers are contiguous, the relative position of the debond (same or opposite sides of their respective fibers) influences the Energy Release Rate (ERR) of the debond. Higher values of Mode I ERR are reached for small debonds placed on the same side of their fibers, while higher values of Mode II ERR are obtained for large debonds on opposite sides. Instead, if just two bonded (undamaged) fibers are present between two debonds along the vertical direction, the ERR becomes insensitive to debonds' relative position.
\keywords{Polymer-matrix Composites (PMCs) \and Transverse Failure \and Debonding \and Finite Element Analysis (FEA)}
% \PACS{PACS code1 \and PACS code2 \and more}
% \subclass{MSC code1 \and MSC code2 \and more}
\end{abstract}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% INTRODUCTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Introduction}
The process of damage onset and development in multi-axial Fiber Reinforced Polymer Composite (FRPC) laminates involves several mechanisms, which concur to the final failure of the composite part. Upon loading, one of the first macroscopic mode of damage is the occurrence of transverse cracks in plies where a tensile stress state is generated predominantly in the direction transverse to the fibers. A single transverse crack does not significantly compromise the load-carrying capacity of the laminate, but in large numbers transverse cracks become detrimental to the elastic response of the loaded part. Furthermore, high concentrantions of transverse cracks lead to stress re-distribution and stress concentrations that can promote other more dangerous modes of fracture, quickly leading to the global failure of the laminate or part. Understanding the factors that influence transverse cracks onset and propagation is thus fundamental to improve current laminate design and to identify mechanisms of controlled propagation, delay and suppression of transverse cracks. This would increase the global fracture toughness of FRPC laminates and help to avoid early part replacement, and thus waste, a practice currently in use to prevent sudden catastrophic brittle failure.\\
Early microscopic observations in glass fiber-epoxy cross-ply laminates determined that onset of transverse cracking occurs at the microscopic level in the form of fiber-matrix interface cracks (or debonds)~\cite{Bailey1981}. Debonds grow along the arc direction of the fiber until reaching a critical size, then kink out of the interface and coalesce with other debonds across the ply thickness~\cite{Zhang1997}. Once a through-the-thickness crack tunnels through the width of the laminate, a transverse crack is formed. Formation and growth of debonds at the microscale thus play a key role in the overall process of initiation of transverse cracking. To improve our understanding of the latter, the former must be studied and modeled.\\
The first investigations on the mechanics of fiber/matrix debonding proposed analytical models of a single partially debonded fiber placed in an infinite matrix. These models focused on understanding the effect of the elastic properties mismatch between fiber and matrix. They were firstly solved by Perlman and Sih~\cite{Perlman1967}, who provided the solution in terms of stress and displacement fields, and Toya~\cite{Toya1974}, who evaluated the Energy Release Rate (ERR) at the debond tip. A closed-form analytical solution could only be found for the \textit{open crack} case, which assumes that no contact between debond faces occurs. This solution was shown to provide, for large debonds, a non-physical solution that implies interpenetration of crack faces~\cite{Toya1974,Comninou1977}. Numerical treatment of the problem soon followed, in particular with the Boundary Element Method (BEM) solution by Paris et al.~\cite{Paris1996}. The numerical analysis of the single fiber model allowed first to understand the importance of crack face contact in the mechanics of fiber/matrix debonding~\cite{Varna1997a}, confirming earlier results regarding the straight bi-material interface crack~\cite{Comninou1977}. The process of fiber/matrix debonding was investigated in models of a single partially debonded fiber embedded in an effectively infinite matrix under remote tension~\cite{Paris1996} and remote compression~\cite{Correa2007}. Residual thermal stresses were also analyzed~\cite{Correa2011}. The effect of a second nearby fiber was studied, under different uniaxial and biaxial tensile and compressive applied loads~\cite{Correa2013,Correa2014,Sandino2016,Sandino2018}. Debond growth in a hexagonal cluster of fibers embedded in an effectively homogenized UD composite was investigated by Zhuang et al.~\cite{Zhuang2018}. The interaction of two debonds facing each other on two nearby fibers was addressed in~\cite{Varna2017} for a cluster of fibers immersed in a homogenized UD.\\
Models of kinking were developed for a single fiber in an infinite matrix~\cite{Paris2007} and a partially debonded fiber in a cluster of fibers inside a homogenized UD~\cite{Zhuang2018a}. A study on linking of debonds was proposed in~\cite{Varna2017}.\\
An analysis of the configuration preceding kinking and linking thus seems to be lacking in the literature. We devote our attention in this paper to the analysis of Representative Volume Elements (RVEs) which model the presence of multiple debonds on fibers aligned across the thickness of UD composites. We focus on understanding the effect of the mutual interaction of consecutive debonds in the vertical direction and of their relative position, i.e. on the same or opposite sides of their respective fibers. We are interested in identifying which mechanisms might favor debond growth and which might, on the other hand, prevent it. For this reason, we select a regular arrangement of fibers and we adopt the approach of Linear Elastic Fracture Mechanics (LEFM) to characterize debond growth, by evaluating Mode I and Mode II Energy Release Rate (ERR). The Finite Element Method (FEM) is chosen to compute stress, strain and displacement fields, which are required to estimate ERR. The characteristics of the RVEs and the Finite Element (FE) solution are described in Sec.~\ref{sec:rveFem}; the main results are reported and discussed in Sec.~\ref{sec:results} and the main conclusions are presented in Sec.~\ref{sec:conclusions}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% RVE MODELS AND FE DISCRETIZATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{RVE models \& FE discretization}\label{sec:rveFem}
\subsection{Introduction, properties and nomenclature}\label{subsec:names}
We focus in this article on debond growth in unidirectional (UD) composites subjected to in-plane transverse tensile loading. In particular, the interaction between debonds is studied through the development of models of Representative Volume Elements (RVEs) of laminates with different configurations of debonds (see Fig.~\ref{fig:laminateModelsA} and Fig.~\ref{fig:laminateModelsB}).
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{coupling.pdf}
\caption{Representative Volume Element $n\times k-symm$ of a UD composite with debonds appearing after $n-1$ and after $k-1$ undamaged fibers respectively in the horizontal and vertical direction. In the vertical direction, on fibers belonging to the same ``column'', debonds are located always on the same side.}\label{fig:laminateModelsA}
\end{figure}
In order to facilitate the description of the models, let us assume that the UD composite mid-plane lies in the $x-y$ plane, where $y$ coincides with the UD $0^{\circ}$ direction while the $x$-axis represents the UD in-plane transverse direction. Axis $z$ is the through-the-thickness direction of the composite.
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{asymm.pdf}
\caption{Representative Volume Element $n\times k-asymm$ of a UD composite with debonds appearing after $n-1$ and after $k-1$ undamaged fibers respectively in the horizontal and vertical direction. In the vertical direction, on fibers belonging to the same ``column'', debonds are located on the opposite sides of consecutive fibers.}\label{fig:laminateModelsB}
\end{figure}
The composite RVE is defined in the $x-z$ plane and is repeating both along $x$ and $z$. Mathematically, it corresponds to an infinite UD composite which models, practically, the behavior of debonds located far away from the UD composite's free surfaces, i.e. close to the laminate mid-plane, in a relatively thick UD composite (thickness $>100$ fiber diameters). The composite with debonds is modeled as a sequence of fiber rows with or without debonds stacked on each other in the vertical (through-the-thickness) direction. Notice that each row contains only one fiber in the vertical direction. A regular microstructure is adopted for all RVEs, with fibers organized in a square-packing configuration. This choice is motivated by our interest in investigating the mechanisms that favor or prevent debond growth, and not in simulating crack path evolution in an arbitrary, randomized distribution of fibers. The regularity of the square-packing arrangement allows the identification of the different mechanisms influencing debond growth. Given their square-packing arrangement of fibers, each RVE is built by using the unit cell in Figure~\ref{fig:modelschem} as the basic building block. The unit cell contains one fiber placed in its center and has a size of $2L\times2L$, where
\begin{equation}\label{eq:LVf}
L=\frac{R_{f}}{2}\sqrt{\frac{\pi}{V_{f}}}.
\end{equation}
In Equation~\ref{eq:LVf}, $V_{f}$ is the fiber volume fraction and $R_{f}$ the fiber radius. The fiber volume fraction is assumed equal to $60\%$ in each RVE and the fiber radius equal to $1\ \mu m$. The choice of the previous value is not dictated by physical considerations but by simplicity. It is thus useful to remark here that, in a linear elastic solution as the one considered in the present work, the ERR is proportional to the geometrical dimensions of the model and, consequently, recalculation of the ERR for fibers of any size requires a simple multiplication. Notice also that, given the relationship in Eq.~\ref{eq:LVf} and that the unit cell is identically repeated following a square-packing configuration, $V_{f}$ is homogeneous, i.e. no clustering of fibers is considered.
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{RUC.pdf}
\caption{Schematic of the model with its main parameters.}\label{fig:modelschem}
\end{figure}
A glass fiber-epoxy UD composite is treated in the present work, and it is assumed that the response of each phase lies always in the linear elastic domain. The material properties of glass fiber and epoxy are reported in Table~\ref{tab:phaseprop}.
\begin{table}[!htbp]
\centering
\caption{Summary of the mechanical properties of fiber and matrix. $E$ stands for Young's modulus, $\mu$ for shear modulus and $\nu$ for Poisson's ratio.}
\begin{tabular}{cccc}
\textbf{Material} & \textbf{$E\left[GPa\right]$}\ & \textbf{$\mu\left[GPa\right]$} & \textbf{$\nu\left[-\right]$} \\
\midrule
Glass fiber & 70.0 & 29.2 & 0.2 \\
Epoxy & 3.5 & 1.25 & 0.4
\end{tabular}
\label{tab:phaseprop}
\end{table}
We consider that upon application of a load in the $x$-direction, the strain response in the $y$-direction is small due to the very small minor Poisson's ratio of the UD composite. We also assume the debond size to be significantly larger in the fiber longitudinal direction than in the arc direction. We therefore use 2D models under the assumption of plane strain defined in the $x-z$ section of the composite, which allows us to focus our interest on debond growth along the arc direction. Assumptions of generalized plane strain would be more suited to represent the physics, however this option would limit the scope of comparisons with previous studies in the literature. It is for this reason that simple plane strain conditions are preferred.\\
All RVEs are symmetric with respect to the horizontal direction, thus only half of the RVE is explicitly modeled and symmetry conditions are applied to the lower boundary of the RVE (Fig.~\ref{fig:laminateModelsA} and Fig.~\ref{fig:laminateModelsB}). The number $n$ of fibers in the horizontal directions and $k$ in the vertical direction belonging to the RVE determine the total size of the RVE, described by its total length $l$ and total height $h$:
\begin{equation}\label{eq:lengthheight}
l=n2L\qquad h=k2L;
\end{equation}
where $2L$ is the side length of the square unit cell previously introduced (Figure~\ref{fig:modelschem}) and $L$ is defined according to Eq.~\ref{eq:LVf}. The number of fibers in the horizontal and vertical directions determine as well the damage state of the modeled UD composite. In particular, a $n\times k$ RVE represents a UD composite in which a debond appear after $n-1$ fully bonded fibers inside a fiber row, and a fiber row contains debonds after $k-1$ fiber rows with no damage (see Fig.~\ref{fig:laminateModelsA} and Fig.~\ref{fig:laminateModelsB}). To model such configurations, conditions of coupling of the horizontal displacement $u_{x}$ are applied to the right and left boundary, which ensure that the computed solution represents a model in which the RVE is repeated infinite times in the horizontal direction. It is worth to highlight that the repetition of the RVE occurs in a mirror-like fashion: moving along the $x$-axis, if a debond appears on the right side of its fiber, the next one is placed on the left side.\\
This might lead to extreme conditions in the model. Consider for example the case of $1\times k$ RVEs: inside a fiber row containing damage, an infinite number of debonds is present and debonds are facing each other pairwise. Such configuration is physically unlikely, however the evaluation of the ERR in this case provides a bound for the case of maximum mutual interaction between debonds in the horizontal direction. Thus, the models proposed here might represent extreme configuration, but they provide theoretical bounds for debond behavior in an actual composite. In particular, observations regarding mechanisms favoring debond growth will represent an upper bound on ERR and thus a conservative estimation of the actual behavior, still of use for the structural designer. Greater care should instead be taken when considering mechanisms preventing debond growth: the ERR estimate provided by our models would be a lower bound, thus debond growth might be higher than predicted in the actual composite.\\
Repetition occurs also along the vertical direction. Here two cases can be distinguished: first, debonds aligned in the vertical direction are placed on the same side of their respective fibers as in Figure~\ref{fig:laminateModelsA}; second; debonds aligned in the vertical direction are placed on alternating opposite sides of their respective fibers as in Figure~\ref{fig:laminateModelsB}. The first is a case of symmetric repetition with respect to the upper boundary of the RVE; the second case is one of anti-symmetric repetition with respect to the upper boundary of the RVE. The two different families of RVEs (symmetric or anti-symmetric repetition) are thus respectively called $n\times k-symm$ and $n\times k-asymm$. The details of the boundary conditions adopted in the two different cases are described in Sec.~\ref{subsec:bc}.
\subsection{Equivalent boundary conditions: description and validation}\label{subsec:bc}
Two main families of Representative Volume Elements have been introduced in the previous section, distinguished by the pattern of debond repetition along the vertical direction: $n\times k-symm$ and $n\times k-asymm$.\\
To model the symmetric repetition of $n\times k-symm$ RVE (Fig.~\ref{fig:laminateModelsA}) we adopt, on the upper boundary, conditions of coupling of the vertical displacements $u_{z}$ of the type
\begin{equation}\label{eq:symmcoupling}
u_{z}\left(x,h\right) = \bar{u}_{z},
\end{equation}
where $h$ is the total height of the RVE defined in Eq.~\ref{eq:lengthheight} and $\bar{u}_{z}$ is a constant value of the vertical displacement, equal for all the points on the upper boundary. The value of $\bar{u}_{z}$ is \emph{a priori} unknown and is evaluated as part of the elastic solution.\\
The anti-symmetric repetition of $n\times k-asymm$ RVE (Fig.~\ref{fig:laminateModelsB}) is modeled with the following set of conditions applied to the vertical displacement $u_{z}$ and horizontal displacement $u_{x}$ on the upper boundary:
\begin{equation}\label{eq:asymmcoupling}
\begin{aligned}
u_{z}\left(x,h\right) - u_{z}\left(0,h\right) &= -\left(u_{z}\left(-x,h\right) - u_{z}\left(0,h\right)\right)\\
u_{x}\left(x,h\right) &= -u_{x}\left(-x,h\right),
\end{aligned}
\end{equation}
where $h$ is again the total height of the RVE and $u_{z}\left(0,h\right)$ is the vertical displacement of the upper boundary mid-point, which is always located at coordinates $(0,h)$. Similarly to $\bar{u}_{z}$ in the symmetric case, $u_{z}\left(0,h\right)$ is \emph{a priori} unknown and is computed as part of the elastic solution.
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{asymm-vs-explmodel-vf60-GI.pdf}
\caption{Validation of asymmetric coupling conditions of Eq.~\ref{eq:asymmcoupling}: Mode I ERR, $V_{f}=60\%$, $\bar{\varepsilon}_{x}=1\%$.}\label{fig:validationGI}
\end{figure}
To the authors' knowledge, this is the first time the set of boundary conditions of Eq.~\ref{eq:asymmcoupling} is proposed and used to model an anti-symmetric coupling as the one represented in Figure~\ref{fig:laminateModelsB}. To validate them, Mode I (Fig.~\ref{fig:validationGI}) and Mode II ERR (Fig.~\ref{fig:validationGII}) are evaluated for $3\times 1-asymm$ RVE and compared with the results of the $3\times201-asymmetric\ debonds\ (explicitly\ modeled)$ RVE, in the case of an applied strain $\bar{\varepsilon}_{x}$ of $1\%$. The $3\times201-asymmetric\ debonds\ (explicitly\ modeled)$ RVE possesses, as all other RVEs studied here, conditions of coupling of the horizontal displacement applied to the left and right side. It is as well symmetric with respect to the $x$-axis, thus only half of the RVE is modeled and conditions of symmetry are applied to the lower horizontal boundary. The upper side of the RVE is, differently from the other models studied here, left free. Debonds are explicitly modeled and placed on alternating sides of vertically aligned fibers, i.e. if a fiber has a debond on the right side the next fiber above will have the debond on the left side. Debonds are all of the same size. The $3\times201-asymmetric\ debonds\ (explicitly\ modeled)$ RVE thus represents the same configuration as the $3\times 1-asymm$ RVE, but it is explicitly modeled. Comparison of the ERR of the two RVEs provides a validation of the accuracy of the conditions expressed in Eq.~\ref{eq:asymmcoupling} as a set of equivalent boundary conditions to represent the situation with alternating debonds (or anti-symmetric coupling) depicted in Fig.~\ref{fig:laminateModelsB}, which is a more effective strategy in terms of computational cost of the model (time and memory needed to compute the solution).
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{asymm-vs-explmodel-vf60-GII.pdf}
\caption{Validation of asymmetric coupling conditions of Eq.~\ref{eq:asymmcoupling}: Mode II ERR, $V_{f}=60\%$, $\bar{\varepsilon}_{x}=1\%$.}\label{fig:validationGII}
\end{figure}
As shown in Figure~\ref{fig:validationGI} and Figure~\ref{fig:validationGII}, a very good agreement is obtained between the results of the two RVEs for both Mode I and Mode II ERR. The validity of the anti-symmetric coupling conditions proposed in Equation~\ref{eq:asymmcoupling} is thus confirmed.
\subsection{Finite Element (FE) solution}
The solution of the elastic problem is obtained with the Finite Element Method (FEM) within the Abaqus environment, a commercial FEM software~\cite{abq12}.\\
The debond is placed symmetrically with respect to the $x$ axis (see Fig.~\ref{fig:modelschem}) and it is characterized by the angular size $\Delta\theta$ (making the full debond size equal to $2\Delta\theta$). For large debond sizes (at least $\geq 60^{\circ}-80^{\circ}$), a region $\Delta\Phi$ of variable size appears at the crack tip where the crack faces are in contact but free to slide relatively to each other. In order to model crack faces motion in the contact zone, frictionless contact is considered between the two crack faces to allow free sliding and avoid interpenetration.\\
A constant displacement is applied to all RVEs, the magnitude of which is selected to have a constant applied horizontal strain $\bar{\varepsilon}_{x}$ equal to $1\%$. The choice of this specific value of the applied strain is actually arbitrary. In the context of Linear Elastic Fracture Mechanics, the Energy Release Rate at the debond tip is proportional to the square of the applied strain. Thus, ERR estimation at a different strain level requires a simple multiplication. Furthermore, our interest is to compare the effect of different mechanisms on debond growth, which we characterize with Mode I and Mode II ERR. As such, our focus is not on providing absolute values of ERR for specific damage configurations, but rather to assess and compare the relative changes in ERR due to modifications of the sorrounding environment. In this perspective, the selection of a rather large value of the applied strain helps our understanding by magnifying the differences in ERR. A further consideration regarding the magnitude of the load needs to be made, regarding the presence of contact between debond faces. The problem solved is a linear problem with non-holonomic constraints due to the non-interpenetration conditions (in the form of inequalities) enforced on the relative displacements of the crack faces. In particular, the problem falls under the definition of receding contact problem~\cite{Paris1996,Garrido1991}. This family of problems in LEFM has some peculiar characteristics~\cite{Garrido1991,Keer1972,Tsai1974}: the size and shape of the contact zone does not depend on the magnitude of the applied load, but only on its type. Thus, upon a change in magnitude of the applied strain $\bar{\varepsilon}_{x}$ the size and shape of the contact zone at the fiber/matrix interface will remain the same.\\
Meshing of the model is accomplished with second order, 2D, plane strain triangular (CPE6, see~\cite{abq12}) and quadrilateral (CPE8, see~\cite{abq12}) elements. An oscillating singularity exists at the debond tip in the stress and displacement fields~\cite{England1971,Toya1974,Comninou1977}. The presence of this singularity prevents the convergence of Mode I and Mode II ERR at the debond tip. Thus, a correct Mode decomposition of the ERR can not be computed in the theoretical limit of an infinitesimal crack increment. It is possible however to avoid the issue by approximating the Mode decomposition over a finite, instead of an infinitesimal, crack increment. This leads naturally to the use of the Virtual Crack Closure Technique (VCCT)~\cite{Krueger2004}, which estimates Mode I and Mode II ERR over a finite crack increment corresponding to the size of the element at the crack tip. To obtain accurate results in terms of Mode decomposition of the ERR, care must be taken in ensuring the quality of the mesh at the debond tip. In particular, a regular mesh of 8-node ($2^{nd}$ order rectangular) elements with almost unitary aspect ratio is constructed at the debond tip. The angular size $\delta$ of an element in the debond tip neighborhood is always equal to $0.05^{\circ}$. The crack faces are modeled as element-based surfaces and a small-sliding contact pair interaction with no friction is imposed between them. The Mode I, Mode II and total Energy Release Rates (ERRs) (respectively referred to as $G_{I}$, $G_{II}$ and $G_{TOT}$) are the main result of FEM simulations; they are evaluated using the VCCT~\cite{Krueger2004} implemented in a in-house Python routine. Validation is performed with respect to the results reported in~\cite{Paris2007,Sandino2016}, which were obtained with the Boundary Element Method (BEM) for a model of a partially debonded single fiber placed in an infinite matrix. As discussed in more detail in~\cite{DiStasio2019}, the agreement between FEM (present work) and BEM~\cite{Paris2007,Sandino2016} solutions is good and the difference between the two does not exceed $5\%$. This provides us with a level of uncertainty with which we can analyze the significance of observed trends: any relative difference in ERR between different RVEs smaller than $5\%$ cannot be reliably distinguished from numerical uncertainty and its discussion should thus be avoided.
\section{Results \& Discussion}\label{sec:results}
\subsection{Effect of debonds mutual position and presence of fiber columns with no damage on the growth of multiple adjacent debonds along the vertical direction}\label{subsec:adjacentdebonds}
We first focus our attention on comparing $n\times 1-symm$ and $n\times 1-asymm$ RVEs, with $n=3,11,101,201$. Both RVEs model a UD composite in which debonds appear on consecutive fibers aligned in the vertical direction, i.e. a ``column'' of fibers or, in the following, simply a fiber column. In $n\times 1-symm$ and $n\times 1-asymm$ a fiber column containing only partially debonded fibers is present after $n-1$ fiber columns with no damage. Two main effects on debond ERR are analyzed through the comparison of these two families of RVEs: for a given type of RVE ($n\times 1-symm$ vs $n\times 1-asymm$), the effect of an increasing number ($n-1$) of fiber columns with no damage between fiber columns containing damage; for a given number ($n-1$) of fiber columns with no damage present between fiber columns containing only partially debonded fibers, the effect of the mutual position of consecutive debonds, i.e. on the same side ($n\times 1-symm$) or on opposite sides ($n\times 1-asymm$) of their respective fiber.
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{nx1-coupling-vf60-GI.pdf}
\caption{Effect of debonds mutual position on Mode I ERR: models $n\times 1-symm$ and $n\times 1-asymm$. $V_{f}=60\%$, $\varepsilon_{x}=1\%$.}\label{fig:nx1GI}
\end{figure}
By looking at Figure~\ref{fig:nx1GI} and Figure~\ref{fig:nx1GII}, it is possible to conclude that, for both $n\times 1-symm$ and $n\times 1-asymm$ RVEs, increasing the number of fiber columns with no damage between fiber columns containing damage causes an increase in both Mode I and Mode II ERR. A few, more specific, observations can be made. For Mode I ERR in Figure~\ref{fig:nx1GI}, increasing the number of fiber columns with no damage causes also a roughly $10^{\circ}$ delay in the onset of the contact zone: from $70^\circ$ to $80^\circ$ for $n\times 1-asymm$ and from $90^\circ$ to $100^\circ$ for $n\times 1-symm$. The occurrence of the maximum value of $G_{I}$ is also delayed: from $10^\circ$ to $20^\circ$ for $n\times 1-asymm$ and from $10^\circ$ to $40^\circ$ for $n\times 1-symm$. For Mode II ERR as well (Figure~\ref{fig:nx1GI}), the occurrence of the maximum value of $G_{II}$ is delayed: from $80^\circ$ to $100^\circ$ for $n\times 1-asymm$ and from $60^\circ$ to $90^\circ$ for $n\times 1-symm$. Comparing on the other hand the ERR of $n\times 1-symm$ and $n\times 1-asymm$ RVEs for a given value of $n$, it is possible to observe that: for Mode I in Figure~\ref{fig:nx1GI}, the ERR is always higher for $n\times 1-symm$, i.e. when debonds occur on the same side of the damaged vertically-aligned fibers; for Mode II in Figure~\ref{fig:nx1GII}, the values of ERR of the two RVEs remain identical or very close to each other when $\Delta\theta<80^{\circ}$,while for larger debonds $n\times 1-asymm$ presents the higher values of ERR.
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{nx1-coupling-vf60-GII.pdf}
\caption{Effect of debonds mutual position on Mode II ERR: models $n\times 1-symm$ and $n\times 1-asymm$. $V_{f}=60\%$, $\varepsilon_{x}=1\%$.}\label{fig:nx1GII}
\end{figure}
The increase in Energy Release Rate due to an increasing number of fiber columns with no damage between fiber columns containing debonds is a consequence of the strain magnification effect. The addition of undamaged elements (fiber columns with no damage) in the RVE causes an increase of the global average $x$-strain in the material and thus an increase of strain and displacement at the debond tip, to which the ERR is proportional. A look at this phenomenon from the opposite point of view is as well helpful to the understanding. From the opposite perspective, Figure~\ref{fig:nx1GI} and Figure~\ref{fig:nx1GII} show that the ERR decreases with an increasing number of fiber columns containing debonds. The presence of cracks, in the form of debonds, in the composite causes discontinuities (or jumps) in the strain and displacement field, which leads to a decrease in the average global strain in the material. As the average global strain decreases, the local values of strain and displacement at the debond tip decrease and thus the Energy Release Rate decreases. The two perspectives are complementary to each other for the understanding of the results in Fig.~\ref{fig:nx1GI} and Fig.~\ref{fig:nx1GII}.\\
In the context of Linear Elastic Fracture Mechanics, a critical Energy Release Rate is assumed to exist and to be a material property, independent of load and geometry. According to Griffith criterion, if the crack ERR is higher than the critical ERR, growth will occur. As a consequence, higher values of ERR could usually be taken as a proxy for the likelihood of crack growth: the configuration with the higher ERR would be the most likely to propagate. Thus, a simple comparison of relative magnitudes of ERR would tell which mechanism favors and which one prevents crack growth. However, the problem is more complex in the case of debonding at the fiber/matrix interface. Although the existence of a critical Energy Release Rate can be postulated, it has been found that its value actually depends on the Mode ratio at the debond tip~\cite{Hutchinson1991}. The functional form of this dependence is still an open issue, although suggestions have been made~\cite{Hutchinson1991,Mantic2009}. A common point of the different criteria proposed for the critical ERR is that it is lower in pure Mode I and Mode I-dominated regimes and increases quickly with the increase of Mode II contribution to the total ERR, reaching the highest value for pure Mode II behavior. It can be concluded that, in general, debonding will more likely occur in pure Mode I or Mode I-dominated rather than pure Mode II or Mode II-dominated loading. Getting back to the results of our analysis, observation of Figure~\ref{fig:nx1GI} implies that a symmetric placement of debonds along the vertical direction, i.e. debonds on the same side of their fibers, would favor the Mode I-dominated growth of small debonds ($\Delta\theta<80^{\circ}-90^{\circ}$) more than an asymmetric placement, i.e. debonds on opposite sides. From observation of Figure~\ref{fig:nx1GII} we can instead conclude that: for large debonds ($\Delta\theta>80^{\circ}-90^{\circ}$) it is likelier that, for a given value of $n$, the ERR-based condition of propagation is satisfied in the case of an asymmetric placement of debonds along the vertical direction, given the higher value of Mode II ERR with the respect to $n\times 1-symm$; provided that for a given value of $n$ the ERR-based condition of propagation is satisfied, larger debond sizes would be obtained in the case of an asymmetric placement of debonds, given that the maximum Mode II ERR occurs at higher values of $\Delta\theta$ for $n\times 1-asymm$ with respect to $n\times 1-symm$.\\
It is further interesting to observe that models $n\times1-symm$ and $n\times1-asymm$ represent, for $n=101,201$, a very localized state of damage and correspond to a configuration rather close to the final stage of transverse crack formation, with debonds still unconnected. On the other hand, for $n=3,11$, $n\times1-symm$ and $n\times1-asymm$ RVEs represent a rather ``diffuse'' damage state. Figure~\ref{fig:nx1GI} shows that, in the case of a ``diffuse'' damage state ($n=3,11$), the difference between \textit{symmetric} and \textit{anti-symmetric} models is rather small. The difference is instead rather drastic in the case of localized damage, with the \textit{symmetric} case having the largest values. Similarly, Figure~\ref{fig:nx1GII} shows that $G_{II}$ is rather insensitive to debond position ($symm$ vs $asymm$) for $n=3,11$, while a significant difference in magnitude between \textit{symmetric} and \textit{anti-symmetric} models is registered for $n=101,201$, with the \textit{anti-symmetric} case providing the highest values. Based on these observations, we can state that in the case of a \emph{strong interface} (i.e. interface strength higher than matrix strength), with kinking occurring when debonds are small, the \textit{symmetric} configuration is the most favorable to debond growth in terms of ERR. On the other hand for a \emph{weak interface} (interface strength lower than matrix strength), with kinking occurring when debonds are large, the \textit{anti-symmetric} configuration is most favorable to debond growth.
\subsection{Effect of the presence of undamaged fibers on debond-debond interaction along the vertical direction}\label{subsec:fibersinbetween}
It is at this point interesting to investigate the effect of the presence of undamaged (fully bonded) fibers between debonds along the vertical direction on debond-debond interaction. To this end, we study the $n\times 3-symm$ and $n\times 3-asymm$ RVEs, with $n=3,7,21,101$.
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{nxk-coupling-vf60-GI.pdf}
\caption{Effect of the presence of undamaged fibers along the vertical direction on Mode I ERR: models $n\times 3-symm$ and $n\times 3-asymm$. $V_{f}=60\%$, $\varepsilon_{x}=1\%$.}\label{fig:nxkGI}
\end{figure}
Results reported in Figure~\ref{fig:nxkGI} and Figure~\ref{fig:nxkGII} respectively for Mode I and Mode II show that the presence of only two undamaged fibers placed between debonds along the vertical direction makes the results of $n\times 3-symm$ and $n\times 3-asymm$ undistinguishable. It appears that the relative placement of debonds does not have any relevant effect on debond ERR, and thus on debond growth, when undamaged fibers are present in between.
\begin{figure}[!h]
\centering
\includegraphics[width=\textwidth]{nxk-coupling-vf60-GII.pdf}
\caption{Effect of the presence of undamaged fibers along the vertical direction on Mode II ERR: models $n\times 3-symm$ and $n\times 3-asymm$. $V_{f}=60\%$, $\varepsilon_{x}=1\%$.}\label{fig:nxkGII}
\end{figure}
Furthermore, comparison of Figure~\ref{fig:nx1GI} with Figure~\ref{fig:nxkGI} for Mode I and of Figure~\ref{fig:nx1GII} with Figure~\ref{fig:nxkGII} for Mode II shows that, especially for Mode II ERR, the presence of fully bonded fibers between debonds along the vertical direction reduces the strain magnification effect due to the presence of additional fiber columns with only fully bonded fibers along the horizontal direction. Mode I reaches a maximum of $5.5\ \nicefrac{J}{m^{2}}$ for $101\times 1-symm$ and $4\ \nicefrac{J}{m^{2}}$ for $101\times 1-asymm$ (Figure~\ref{fig:nx1GI}), and of $3.5\ \nicefrac{J}{m^{2}}$ for both $101\times 3-symm$ and $101\times 3-asymm$ (Figure~\ref{fig:nxkGI}). The maximum value of Mode II is $30\ \nicefrac{J}{m^{2}}$ for $101\times 1-symm$ and $42.5\ \nicefrac{J}{m^{2}}$ for $101\times 1-asymm$ (Figure~\ref{fig:nx1GII}), and of $4.75\ \nicefrac{J}{m^{2}}$ for both $101\times 3-symm$ and $101\times 3-asymm$ (Figure~\ref{fig:nxkGII}).%\\
%It is worth observing that $n\times 3-symm$ and $n\times 3-asymm$ RVEs represent a more ``diffuse'' state of damage than $n\times 1-symm$ and $n\times 1-asymm$. Comparison of Figure~\ref{fig:nx1GI} and Figure~\ref{fig:nx1GII} with respectively Figure~\ref{fig:nxkGI} and Figure~\ref{fig:nxkGII} reveals that a huge difference in Mode II ERR exists between the localized ($n\times 1$) and diffuse ($n\times 3$) damage states, with lower values of $G_{II}$ occurring for the ``diffuse'' less dense $n\times 3$ configuration.
\subsection{Effect of the presence of a finite number of debonds in the vertical direction}\label{subsec:finitenumdebonds}
\begin{figure}[!h]
\centering
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{asymm-explicitmodel-increasing-vf60-GI.pdf}
\caption{Mode I.}\label{subfig:finitedebsalternatingGI}
\end{subfigure} ~
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{asymm-explicitmodel-increasing-vf60-GII.pdf}
\caption{Mode II.}\label{subfig:finitedebsalternatingGII}
\end{subfigure}
\caption{Effect on Mode I and Mode II ERR of a finite increasing number of alternating debonds along the vertical direction for a $21\times41-free$ RVE, $V_{f}=60\%$, $\varepsilon_{x}$ of $1\%$.}\label{fig:finitedebsalternating}
\end{figure}
\begin{figure}[!h]
\centering
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{symm-explicitmodel-increasing-vf60-GI.pdf}
\caption{Mode I.}\label{subfig:finitedebsalternatingGI}
\end{subfigure} ~
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{symm-explicitmodel-increasing-vf60-GII.pdf}
\caption{Mode II.}\label{subfig:finitedebsalignedGII}
\end{subfigure}
\caption{Effect on Mode I and Mode II ERR of a finite increasing number of aligned debonds along the vertical direction for a $21\times41-free$ RVE, $V_{f}=60\%$, $\varepsilon_{x}$ of $1\%$.}\label{fig:finitedebsaligned}
\end{figure}
\begin{figure}[!h]
\centering
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{comparison-explicitmodel-3debs-vf60-GI.pdf}
\caption{3 debonds.}\label{subfig:finitedebscomparisonModeI3debs}
\end{subfigure} ~
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{comparison-explicitmodel-5debs-vf60-GI.pdf}
\caption{5 debonds.}\label{subfig:finitedebscomparisonModeI5debs}
\end{subfigure}
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{comparison-explicitmodel-11debs-vf60-GI.pdf}
\caption{11 debonds.}\label{subfig:finitedebscomparisonModeI11debs}
\end{subfigure} ~
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{comparison-explicitmodel-21debs-vf60-GI.pdf}
\caption{21 debonds.}\label{subfig:finitedebscomparisonModeI21debs}
\end{subfigure}
\caption{Effect on Mode I ERR of a finite increasing number of debonds along the vertical direction for a $21\times41-free$ RVE: comparison between alternating and aligned debonds. $V_{f}=60\%$, $\varepsilon_{x}$ of $1\%$.}\label{fig:finitedebscomparisonModeI}
\end{figure}
\begin{figure}[!h]
\centering
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{comparison-explicitmodel-3debs-vf60-GII.pdf}
\caption{3 debonds.}\label{subfig:finitedebscomparisonModeII3debs}
\end{subfigure} ~
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{comparison-explicitmodel-5debs-vf60-GII.pdf}
\caption{5 debonds.}\label{subfig:finitedebscomparisonModeII5debs}
\end{subfigure}
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{comparison-explicitmodel-11debs-vf60-GII.pdf}
\caption{11 debonds.}\label{subfig:finitedebscomparisonModeII11debs}
\end{subfigure} ~
\begin{subfigure}[b]{0.475\textwidth}
\includegraphics[width=\textwidth]{comparison-explicitmodel-21debs-vf60-GII.pdf}
\caption{21 debonds.}\label{subfig:finitedebscomparisonModeII21debs}
\end{subfigure}
\caption{Effect on Mode II ERR of a finite increasing number of debonds along the vertical direction for a $21\times41-free$ RVE: comparison between alternating and aligned debonds. $V_{f}=60\%$, $\varepsilon_{x}$ of $1\%$.}\label{fig:finitedebscomparisonModeII}
\end{figure}
\begin{enumerate}
\item Alternating debonds, Mode I, Figure~\ref{subfig:finitedebsalternatingGI}: no change with increasing number of debonds and no difference with models $101\times1-alternating$ and $201\times1-alternating$, which correspond to an infinite number of debonds along the vertical direction. Apparently, having just the side of the above fiber fully bonded makes the debond unaffected by the presence of another debond: 1) on the opposite side of the fiber just above, 2) on the same side of the subsequent fiber above.
\item Alternating debonds, Mode II, Figure~\ref{subfig:finitedebsalternatingGII}: it increases with an increasing number of debonds and it is different from models $101\times1-alternating$ and $201\times1-alternating$, which correspond to an infinite number of debonds along the vertical direction. One main difference: two peaks appear, i.e. one local and one global maximum, respectively at $\Delta\theta=80^{\circ}$ and $\Delta\theta=100^{\circ}$. Given that Mode II for $21\times41-11\ alternating\ debonds$ and $21\times41-21\ alternating\ debonds$ are practically identical, we can conclude that there exists a maximum number of debonds after which the marginal effect on ERR of adding an additional one is negligible, or otherwise that there is a ``critical interaction length''.
\item Aligned debonds, Mode I, Figure~\ref{subfig:finitedebsalignedGI}: it increases with increasing number of debonds. One difference with $101\times1-aligned$ and $201\times1-aligned$ which correspond to an infinite number of debonds along the vertical direction: a second local maximum at $\Delta\theta=70^{\circ}$ appears, more markedly with increasing number of debonds. Also, onset of contact zone is shifted from $\Delta\theta=80^{\circ}$ for $3$ aligned debonds to $\Delta\theta=90^{\circ}$ for at least $5$ aligned debonds.
\item Aligned debonds, Mode II, Figure~\ref{subfig:finitedebsalignedGII}: it increases with increasing number of debonds. One difference with $101\times1-aligned$ and $201\times1-aligned$ which correspond to an infinite number of debonds along the vertical direction: two local maximum points appear at $\Delta\theta=50^{\circ}$ and at $\Delta\theta=100^{\circ}$. The first, at $\Delta\theta=50^{\circ}$, becomes less marked with increasing number of debonds, the second at $\Delta\theta=100^{\circ}$ becomes more marked with increasing number of debonds. The global maximum is at $70^{\circ}$ for $3$ aligned debonds and $80^{\circ}$ for at least $5$ aligned debonds.
\item Aligned debonds, Mode I and Mode II, Figure~\ref{fig:finitedebsaligned}: given that ERR for $21\times41-11\ aligned\ debonds$ and $21\times41-21\ aligned\ debonds$ are almost identical, we can conclude that there exists also for the aligned case a maximum number of debonds after which the marginal effect on ERR of adding an additional one is negligible, or otherwise that there is a ``critical interaction length''.
\item Comparison alternating-aligned: given the same number of debonds, Mode I ERR (Figure~\ref{fig:finitedebscomparisonModeI}) is higher in the case of aligned debonds, Mode II (Figure~\ref{fig:finitedebscomparisonModeII}) is higher in the case of alternating debonds, which is the same result obtained for the models with equivalent boundary conditions.
\end{enumerate}
\section{Conclusions}\label{sec:conclusions}
The effect of debond-debond interaction along the vertical direction and the influence of debond relative position of their respective fibers have been studied with the use of Representative Volume Elements of thick UD composites. Debond growth has been characterized using tools of Linear Elastic Fracture Mechanics, specifically Mode I and Mode II Energy Release Rate at the debond tip. Two specific configurations have been chosen to investigate the effect of debond relative position: debonds placed on the same side of fibers aligned in the vertical direction, or symmetric repetition, and debonds placed on opposite sides of fibers aligned in the vertical direction, or asymmetric repetition. To model the former, classic conditions of coupling of the vertical displacements on the upper boundary have been employed. To model the asymmetric repetition configuration, a set of boundary conditions, to which we have refered to as anti-symmetric coupling, has been proposed. To the authors' knowledge, this is the first time the anti-symmetric coupling conditions have been proposed in the context of RVE modeling of heterogeneous materials behavior. For this reason, the boundary conditions proposed have been validated with respect to a RVE with debonds explicitly modeled and placed on alternating sides of fibers aligned in the vertical direction. The agreeement between the model with explicitly modeled debonds and the one with equivalent boundary conditions has been found excellent.\\
Comparison of Mode I and Mode II Energy Release Rate between the two configurations (symmetric and asymmetric repetition of debonds) reveals that:
\begin{itemize}
\item higher values of Mode I ERR are found for a debond placed in a fiber column with no undamaged fiber inside and debonds placed on the same side of partially debonded fibers;
\item higher values of Mode II ERR are obtained for a debond placed in a fiber column with no undamaged fiber inside and debonds placed on opposite sides of partially debonded fibers;
\item no effect of debonds relative position on ERR is registered in the presence of just two undamaged (fully bonded) fibers between two debonds along the vertical direction;
\item the presence of just two undamaged (fully bonded) fibers between two debonds along the vertical direction reduces, especially for Mode II, the effect of strain magnification.
\end{itemize}
\begin{acknowledgements}
Luca Di Stasio gratefully acknowledges the support of the European School of Materials (EUSMAT) through the DocMASE Doctoral Programme and the European Commission through the Erasmus Mundus Programme.
\end{acknowledgements}
% Authors must disclose all relationships or interests that
% could have direct or potential influence or impart bias on
% the work:
%
% \section*{Conflict of interest}
%
% The authors declare that they have no conflict of interest.
% BibTeX users please use one of
%\bibliographystyle{spbasic} % basic style, author-year citations
\bibliographystyle{spmpsci} % mathematics and physical sciences
%\bibliographystyle{spphys} % APS-like style for physics
\bibliography{refs} % name your BibTeX data base
%% Non-BibTeX users please use
%\begin{thebibliography}{}
%%
%% and use \bibitem to create references. Consult the Instructions
%% for authors for reference list style.
%%
%\bibitem{RefJ}
%% Format for Journal Reference
%Author, Article title, Journal, Volume, page numbers (year)
%% Format for books
%\bibitem{RefB}
%Author, Book title, page numbers. Publisher, place (year)
%% etc
%\end{thebibliography}
\end{document}
% end of file template.tex
|
# BogumiΕ KamiΕski, 2019-03-25
using DataFrames, CSV
df = CSV.read("iris.csv")
describe(df)
df2 = stack(df)
CSV.write("iris2.csv", df2)
|
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have h4f : ContinuousAt (fun x => f x (g x)) xβ :=
ContinuousAt.comp_of_eq hf.continuousAt (continuousAt_id.prod hg.continuousAt) rfl
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4f : ContinuousAt (fun x => f x (g x)) xβ
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have h4f := h4f.preimage_mem_nhds (extChartAt_source_mem_nhds I' (f xβ (g xβ)))
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have h3f := contMDiffAt_iff_contMDiffAt_nhds.mp (hf.of_le <| (self_le_add_left 1 m).trans hmn)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have h2f : βαΆ xβ in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ) :=
by
refine' ((continuousAt_id.prod hg.continuousAt).tendsto.eventually h3f).mono fun x hx => _
exact hx.comp (g x) (contMDiffAt_const.prod_mk contMDiffAt_id)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
β’ βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
[PROOFSTEP]
refine' ((continuousAt_id.prod hg.continuousAt).tendsto.eventually h3f).mono fun x hx => _
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
x : N
hx : ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) (id x, g x)
β’ ContMDiffAt I I' 1 (f x) (g x)
[PROOFSTEP]
exact hx.comp (g x) (contMDiffAt_const.prod_mk contMDiffAt_id)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have h2g := hg.continuousAt.preimage_mem_nhds (extChartAt_source_mem_nhds I (g xβ))
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have :
ContDiffWithinAt π m
(fun x =>
fderivWithin π (extChartAt I' (f xβ (g xβ)) β f ((extChartAt J xβ).symm x) β (extChartAt I (g xβ)).symm) (range I)
(extChartAt I (g xβ) (g ((extChartAt J xβ).symm x))))
(range J) (extChartAt J xβ xβ) :=
by
rw [contMDiffAt_iff] at hf hg
simp_rw [Function.comp, uncurry, extChartAt_prod, LocalEquiv.prod_coe_symm, ModelWithCorners.range_prod] at hf β’
refine' ContDiffWithinAt.fderivWithin _ hg.2 I.unique_diff hmn (mem_range_self _) _
Β· simp_rw [extChartAt_to_inv]; exact hf.2
Β· rw [β image_subset_iff]
rintro _ β¨x, -, rflβ©
exact mem_range_self _
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
β’ ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
[PROOFSTEP]
rw [contMDiffAt_iff] at hf hg
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf :
ContinuousAt (uncurry f) (xβ, g xβ) β§
ContDiffWithinAt π n
(β(extChartAt I' (uncurry f (xβ, g xβ))) β
uncurry f β β(LocalEquiv.symm (extChartAt (ModelWithCorners.prod J I) (xβ, g xβ))))
(range β(ModelWithCorners.prod J I)) (β(extChartAt (ModelWithCorners.prod J I) (xβ, g xβ)) (xβ, g xβ))
hg :
ContinuousAt g xβ β§
ContDiffWithinAt π m (β(extChartAt I (g xβ)) β g β β(LocalEquiv.symm (extChartAt J xβ))) (range βJ)
(β(extChartAt J xβ) xβ)
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
β’ ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
[PROOFSTEP]
simp_rw [Function.comp, uncurry, extChartAt_prod, LocalEquiv.prod_coe_symm, ModelWithCorners.range_prod] at hf β’
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hg :
ContinuousAt g xβ β§
ContDiffWithinAt π m (β(extChartAt I (g xβ)) β g β β(LocalEquiv.symm (extChartAt J xβ))) (range βJ)
(β(extChartAt J xβ) xβ)
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
hf :
ContinuousAt (fun a => f a.fst a.snd) (xβ, g xβ) β§
ContDiffWithinAt π n
(fun x =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x.fst) (β(LocalEquiv.symm (extChartAt I (g xβ))) x.snd)))
(range βJ ΓΛ’ range βI) (β(LocalEquiv.prod (extChartAt J xβ) (extChartAt I (g xβ))) (xβ, g xβ))
β’ ContDiffWithinAt π m
(fun x =>
fderivWithin π
(fun x_1 =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x) (β(LocalEquiv.symm (extChartAt I (g xβ))) x_1)))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
[PROOFSTEP]
refine' ContDiffWithinAt.fderivWithin _ hg.2 I.unique_diff hmn (mem_range_self _) _
[GOAL]
case refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hg :
ContinuousAt g xβ β§
ContDiffWithinAt π m (β(extChartAt I (g xβ)) β g β β(LocalEquiv.symm (extChartAt J xβ))) (range βJ)
(β(extChartAt J xβ) xβ)
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
hf :
ContinuousAt (fun a => f a.fst a.snd) (xβ, g xβ) β§
ContDiffWithinAt π n
(fun x =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x.fst) (β(LocalEquiv.symm (extChartAt I (g xβ))) x.snd)))
(range βJ ΓΛ’ range βI) (β(LocalEquiv.prod (extChartAt J xβ) (extChartAt I (g xβ))) (xβ, g xβ))
β’ ContDiffWithinAt π n
(uncurry fun x x_1 =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x) (β(LocalEquiv.symm (extChartAt I (g xβ))) x_1)))
(range βJ ΓΛ’ range βI)
(β(extChartAt J xβ) xβ, β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) (β(extChartAt J xβ) xβ))))
[PROOFSTEP]
simp_rw [extChartAt_to_inv]
[GOAL]
case refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hg :
ContinuousAt g xβ β§
ContDiffWithinAt π m (β(extChartAt I (g xβ)) β g β β(LocalEquiv.symm (extChartAt J xβ))) (range βJ)
(β(extChartAt J xβ) xβ)
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
hf :
ContinuousAt (fun a => f a.fst a.snd) (xβ, g xβ) β§
ContDiffWithinAt π n
(fun x =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x.fst) (β(LocalEquiv.symm (extChartAt I (g xβ))) x.snd)))
(range βJ ΓΛ’ range βI) (β(LocalEquiv.prod (extChartAt J xβ) (extChartAt I (g xβ))) (xβ, g xβ))
β’ ContDiffWithinAt π n
(uncurry fun x x_1 =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x) (β(LocalEquiv.symm (extChartAt I (g xβ))) x_1)))
(range βJ ΓΛ’ range βI) (β(extChartAt J xβ) xβ, β(extChartAt I (g xβ)) (g xβ))
[PROOFSTEP]
exact hf.2
[GOAL]
case refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hg :
ContinuousAt g xβ β§
ContDiffWithinAt π m (β(extChartAt I (g xβ)) β g β β(LocalEquiv.symm (extChartAt J xβ))) (range βJ)
(β(extChartAt J xβ) xβ)
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
hf :
ContinuousAt (fun a => f a.fst a.snd) (xβ, g xβ) β§
ContDiffWithinAt π n
(fun x =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x.fst) (β(LocalEquiv.symm (extChartAt I (g xβ))) x.snd)))
(range βJ ΓΛ’ range βI) (β(LocalEquiv.prod (extChartAt J xβ) (extChartAt I (g xβ))) (xβ, g xβ))
β’ range βJ β (fun x => β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))) β»ΒΉ' range βI
[PROOFSTEP]
rw [β image_subset_iff]
[GOAL]
case refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hg :
ContinuousAt g xβ β§
ContDiffWithinAt π m (β(extChartAt I (g xβ)) β g β β(LocalEquiv.symm (extChartAt J xβ))) (range βJ)
(β(extChartAt J xβ) xβ)
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
hf :
ContinuousAt (fun a => f a.fst a.snd) (xβ, g xβ) β§
ContDiffWithinAt π n
(fun x =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x.fst) (β(LocalEquiv.symm (extChartAt I (g xβ))) x.snd)))
(range βJ ΓΛ’ range βI) (β(LocalEquiv.prod (extChartAt J xβ) (extChartAt I (g xβ))) (xβ, g xβ))
β’ (fun x => β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))) '' range βJ β range βI
[PROOFSTEP]
rintro _ β¨x, -, rflβ©
[GOAL]
case refine'_2.intro.intro
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hg :
ContinuousAt g xβ β§
ContDiffWithinAt π m (β(extChartAt I (g xβ)) β g β β(LocalEquiv.symm (extChartAt J xβ))) (range βJ)
(β(extChartAt J xβ) xβ)
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
hf :
ContinuousAt (fun a => f a.fst a.snd) (xβ, g xβ) β§
ContDiffWithinAt π n
(fun x =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x.fst) (β(LocalEquiv.symm (extChartAt I (g xβ))) x.snd)))
(range βJ ΓΛ’ range βI) (β(LocalEquiv.prod (extChartAt J xβ) (extChartAt I (g xβ))) (xβ, g xβ))
x : F
β’ (fun x => β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))) x β range βI
[PROOFSTEP]
exact mem_range_self _
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
this :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (extChartAt I' (f xβ (g xβ)) β f x β (extChartAt I (g xβ)).symm) (range I)
(extChartAt I (g xβ) (g x)))
xβ :=
by
simp_rw [contMDiffAt_iff_source_of_mem_source (mem_chart_source G xβ), contMDiffWithinAt_iff_contDiffWithinAt,
Function.comp]
exact this
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
this :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
β’ ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
[PROOFSTEP]
simp_rw [contMDiffAt_iff_source_of_mem_source (mem_chart_source G xβ), contMDiffWithinAt_iff_contDiffWithinAt,
Function.comp]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
this :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
β’ ContDiffWithinAt π m
(fun x =>
fderivWithin π
(fun x_1 =>
β(extChartAt I' (f xβ (g xβ)))
(f (β(LocalEquiv.symm (extChartAt J xβ)) x) (β(LocalEquiv.symm (extChartAt I (g xβ))) x_1)))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
[PROOFSTEP]
exact this
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(extChartAt I' (f xβ (g xβ)) β
(extChartAt I' (f x (g x))).symm β
writtenInExtChartAt I I' (g x) (f x) β extChartAt I (g x) β (extChartAt I (g xβ)).symm)
(range I) (extChartAt I (g xβ) (g x)))
xβ :=
by
refine' this.congr_of_eventuallyEq _
filter_upwards [h2g, h2f]
intro xβ hxβ h2xβ
have :
β
x β
(extChartAt I (g xβ)).symm β»ΒΉ' (extChartAt I (g xβ)).source β©
(extChartAt I (g xβ)).symm β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source),
(extChartAt I' (f xβ (g xβ)) β
(extChartAt I' (f xβ (g xβ))).symm β
writtenInExtChartAt I I' (g xβ) (f xβ) β extChartAt I (g xβ) β (extChartAt I (g xβ)).symm)
x =
extChartAt I' (f xβ (g xβ)) (f xβ ((extChartAt I (g xβ)).symm x)) :=
by
rintro x β¨hx, h2xβ©
simp_rw [writtenInExtChartAt, Function.comp_apply]
rw [(extChartAt I (g xβ)).left_inv hx, (extChartAt I' (f xβ (g xβ))).left_inv h2x]
refine' Filter.EventuallyEq.fderivWithin_eq_nhds _
refine' eventually_of_mem (inter_mem _ _) this
Β· exact extChartAt_preimage_mem_nhds' _ _ hxβ (extChartAt_source_mem_nhds I (g xβ))
refine' extChartAt_preimage_mem_nhds' _ _ hxβ _
exact
h2xβ.continuousAt.preimage_mem_nhds
(extChartAt_source_mem_nhds _ _)
/- The conclusion is equal to the following, when unfolding coord_change of
`tangentBundleCore` -/
-- Porting note: added
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
β’ ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
[PROOFSTEP]
refine' this.congr_of_eventuallyEq _
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
β’ (fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x))) =αΆ [π xβ]
fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x))
[PROOFSTEP]
filter_upwards [h2g, h2f]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
β’ β (a : N),
a β g β»ΒΉ' (extChartAt I (g xβ)).source β
ContMDiffAt I I' 1 (f a) (g a) β
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f a (g a)))) β
writtenInExtChartAt I I' (g a) (f a) β β(extChartAt I (g a)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g a)) =
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f a β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g a))
[PROOFSTEP]
intro xβ hxβ h2xβ
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
β’ fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g xβ)) =
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f xβ β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
[PROOFSTEP]
have :
β
x β
(extChartAt I (g xβ)).symm β»ΒΉ' (extChartAt I (g xβ)).source β©
(extChartAt I (g xβ)).symm β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source),
(extChartAt I' (f xβ (g xβ)) β
(extChartAt I' (f xβ (g xβ))).symm β
writtenInExtChartAt I I' (g xβ) (f xβ) β extChartAt I (g xβ) β (extChartAt I (g xβ)).symm)
x =
extChartAt I' (f xβ (g xβ)) (f xβ ((extChartAt I (g xβ)).symm x)) :=
by
rintro x β¨hx, h2xβ©
simp_rw [writtenInExtChartAt, Function.comp_apply]
rw [(extChartAt I (g xβ)).left_inv hx, (extChartAt I' (f xβ (g xβ))).left_inv h2x]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
β’ β (x : E),
x β
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source β©
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source) β
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β
β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
x =
β(extChartAt I' (f xβ (g xβ))) (f xβ (β(LocalEquiv.symm (extChartAt I (g xβ))) x))
[PROOFSTEP]
rintro x β¨hx, h2xβ©
[GOAL]
case intro
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
x : E
hx : x β β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source
h2x : x β β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source)
β’ (β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
x =
β(extChartAt I' (f xβ (g xβ))) (f xβ (β(LocalEquiv.symm (extChartAt I (g xβ))) x))
[PROOFSTEP]
simp_rw [writtenInExtChartAt, Function.comp_apply]
[GOAL]
case intro
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
x : E
hx : x β β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source
h2x : x β β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source)
β’ β(extChartAt I' (f xβ (g xβ)))
(β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ))))
(β(extChartAt I' (f xβ (g xβ)))
(f xβ
(β(LocalEquiv.symm (extChartAt I (g xβ)))
(β(extChartAt I (g xβ)) (β(LocalEquiv.symm (extChartAt I (g xβ))) x)))))) =
β(extChartAt I' (f xβ (g xβ))) (f xβ (β(LocalEquiv.symm (extChartAt I (g xβ))) x))
[PROOFSTEP]
rw [(extChartAt I (g xβ)).left_inv hx, (extChartAt I' (f xβ (g xβ))).left_inv h2x]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
this :
β (x : E),
x β
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source β©
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source) β
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β
β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
x =
β(extChartAt I' (f xβ (g xβ))) (f xβ (β(LocalEquiv.symm (extChartAt I (g xβ))) x))
β’ fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g xβ)) =
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f xβ β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
[PROOFSTEP]
refine' Filter.EventuallyEq.fderivWithin_eq_nhds _
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
this :
β (x : E),
x β
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source β©
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source) β
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β
β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
x =
β(extChartAt I' (f xβ (g xβ))) (f xβ (β(LocalEquiv.symm (extChartAt I (g xβ))) x))
β’ β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β
β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))) =αΆ [π (β(extChartAt I (g xβ)) (g xβ))]
β(extChartAt I' (f xβ (g xβ))) β f xβ β β(LocalEquiv.symm (extChartAt I (g xβ)))
[PROOFSTEP]
refine' eventually_of_mem (inter_mem _ _) this
[GOAL]
case h.refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
this :
β (x : E),
x β
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source β©
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source) β
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β
β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
x =
β(extChartAt I' (f xβ (g xβ))) (f xβ (β(LocalEquiv.symm (extChartAt I (g xβ))) x))
β’ β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source β π (β(extChartAt I (g xβ)) (g xβ))
[PROOFSTEP]
exact extChartAt_preimage_mem_nhds' _ _ hxβ (extChartAt_source_mem_nhds I (g xβ))
[GOAL]
case h.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
this :
β (x : E),
x β
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source β©
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source) β
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β
β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
x =
β(extChartAt I' (f xβ (g xβ))) (f xβ (β(LocalEquiv.symm (extChartAt I (g xβ))) x))
β’ β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source) β
π (β(extChartAt I (g xβ)) (g xβ))
[PROOFSTEP]
refine' extChartAt_preimage_mem_nhds' _ _ hxβ _
[GOAL]
case h.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
this :
β (x : E),
x β
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (extChartAt I (g xβ)).source β©
β(LocalEquiv.symm (extChartAt I (g xβ))) β»ΒΉ' (f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source) β
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β
β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
x =
β(extChartAt I' (f xβ (g xβ))) (f xβ (β(LocalEquiv.symm (extChartAt I (g xβ))) x))
β’ f xβ β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π (g xβ)
[PROOFSTEP]
exact
h2xβ.continuousAt.preimage_mem_nhds
(extChartAt_source_mem_nhds _ _)
/- The conclusion is equal to the following, when unfolding coord_change of
`tangentBundleCore` -/
-- Porting note: added
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
letI _inst : β x, NormedAddCommGroup (TangentSpace I (g x)) := fun _ => inferInstanceAs (NormedAddCommGroup E)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_inst : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
letI _inst : β x, NormedSpace π (TangentSpace I (g x)) := fun _ => inferInstanceAs (NormedSpace π E)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
have :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
(fderivWithin π (extChartAt I' (f xβ (g xβ)) β (extChartAt I' (f x (g x))).symm) (range I')
(extChartAt I' (f x (g x)) (f x (g x)))).comp
((mfderiv I I' (f x) (g x)).comp
(fderivWithin π (extChartAt I (g x) β (extChartAt I (g xβ)).symm) (range I) (extChartAt I (g xβ) (g x)))))
xβ :=
by
refine' this.congr_of_eventuallyEq _
filter_upwards [h2g, h2f, h4f]
intro xβ hxβ h2xβ h3xβ
symm
rw [(h2xβ.mdifferentiableAt le_rfl).mfderiv]
have hI :=
(contDiffWithinAt_ext_coord_change I (g xβ) (g xβ) <|
LocalEquiv.mem_symm_trans_source _ hxβ <| mem_extChartAt_source I (g xβ)).differentiableWithinAt
le_top
have hI' :=
(contDiffWithinAt_ext_coord_change I' (f xβ (g xβ)) (f xβ (g xβ)) <|
LocalEquiv.mem_symm_trans_source _ (mem_extChartAt_source I' (f xβ (g xβ))) h3xβ).differentiableWithinAt
le_top
have h3f := (h2xβ.mdifferentiableAt le_rfl).2
refine' fderivWithin.compβ _ hI' h3f hI _ _ _ _ (I.unique_diff _ <| mem_range_self _)
Β· exact fun x _ => mem_range_self _
Β· exact fun x _ => mem_range_self _
Β· simp_rw [writtenInExtChartAt, Function.comp_apply, (extChartAt I (g xβ)).left_inv (mem_extChartAt_source I (g xβ))]
Β· simp_rw [Function.comp_apply, (extChartAt I (g xβ)).left_inv hxβ]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
β’ ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))))
xβ
[PROOFSTEP]
refine' this.congr_of_eventuallyEq _
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
β’ (fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x))))) =αΆ [π xβ]
fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x))
[PROOFSTEP]
filter_upwards [h2g, h2f, h4f]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
β’ β (a : N),
a β g β»ΒΉ' (extChartAt I (g xβ)).source β
ContMDiffAt I I' 1 (f a) (g a) β
a β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f a (g a)))))
(range βI') (β(extChartAt I' (f a (g a))) (f a (g a))))
(ContinuousLinearMap.comp (mfderiv I I' (f a) (g a))
(fderivWithin π (β(extChartAt I (g a)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g a)))) =
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f a (g a)))) β
writtenInExtChartAt I I' (g a) (f a) β
β(extChartAt I (g a)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g a))
[PROOFSTEP]
intro xβ hxβ h2xβ h3xβ
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
β’ ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ))))) (range βI')
(β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ))))
(ContinuousLinearMap.comp (mfderiv I I' (f xβ) (g xβ))
(fderivWithin π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ)))) =
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g xβ))
[PROOFSTEP]
symm
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
β’ fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g xβ)) =
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ))))) (range βI')
(β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ))))
(ContinuousLinearMap.comp (mfderiv I I' (f xβ) (g xβ))
(fderivWithin π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))))
[PROOFSTEP]
rw [(h2xβ.mdifferentiableAt le_rfl).mfderiv]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
β’ fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g xβ)) =
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ))))) (range βI')
(β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ))))
(ContinuousLinearMap.comp
(fderivWithin π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ)))
(fderivWithin π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))))
[PROOFSTEP]
have hI :=
(contDiffWithinAt_ext_coord_change I (g xβ) (g xβ) <|
LocalEquiv.mem_symm_trans_source _ hxβ <| mem_extChartAt_source I (g xβ)).differentiableWithinAt
le_top
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
hI :
DifferentiableWithinAt π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
β’ fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g xβ)) =
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ))))) (range βI')
(β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ))))
(ContinuousLinearMap.comp
(fderivWithin π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ)))
(fderivWithin π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))))
[PROOFSTEP]
have hI' :=
(contDiffWithinAt_ext_coord_change I' (f xβ (g xβ)) (f xβ (g xβ)) <|
LocalEquiv.mem_symm_trans_source _ (mem_extChartAt_source I' (f xβ (g xβ))) h3xβ).differentiableWithinAt
le_top
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
hI :
DifferentiableWithinAt π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
hI' :
DifferentiableWithinAt π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))))
(range βI') (β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ)))
β’ fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g xβ)) =
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ))))) (range βI')
(β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ))))
(ContinuousLinearMap.comp
(fderivWithin π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ)))
(fderivWithin π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))))
[PROOFSTEP]
have h3f := (h2xβ.mdifferentiableAt le_rfl).2
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3fβ : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
hI :
DifferentiableWithinAt π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
hI' :
DifferentiableWithinAt π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))))
(range βI') (β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ)))
h3f : DifferentiableWithinAt π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ))
β’ fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))) β
writtenInExtChartAt I I' (g xβ) (f xβ) β β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g xβ)) =
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ))))) (range βI')
(β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ))))
(ContinuousLinearMap.comp
(fderivWithin π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ)))
(fderivWithin π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))))
[PROOFSTEP]
refine' fderivWithin.compβ _ hI' h3f hI _ _ _ _ (I.unique_diff _ <| mem_range_self _)
[GOAL]
case h.refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3fβ : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
hI :
DifferentiableWithinAt π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
hI' :
DifferentiableWithinAt π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))))
(range βI') (β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ)))
h3f : DifferentiableWithinAt π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ))
β’ MapsTo (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (range βI')
[PROOFSTEP]
exact fun x _ => mem_range_self _
[GOAL]
case h.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3fβ : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
hI :
DifferentiableWithinAt π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
hI' :
DifferentiableWithinAt π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))))
(range βI') (β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ)))
h3f : DifferentiableWithinAt π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ))
β’ MapsTo (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI) (range βI)
[PROOFSTEP]
exact fun x _ => mem_range_self _
[GOAL]
case h.refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3fβ : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
hI :
DifferentiableWithinAt π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
hI' :
DifferentiableWithinAt π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))))
(range βI') (β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ)))
h3f : DifferentiableWithinAt π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ))
β’ writtenInExtChartAt I I' (g xβ) (f xβ) (β(extChartAt I (g xβ)) (g xβ)) = β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ))
[PROOFSTEP]
simp_rw [writtenInExtChartAt, Function.comp_apply, (extChartAt I (g xβ)).left_inv (mem_extChartAt_source I (g xβ))]
[GOAL]
case h.refine'_4
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3fβ : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒΉ :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
xβ : N
hxβ : xβ β g β»ΒΉ' (extChartAt I (g xβ)).source
h2xβ : ContMDiffAt I I' 1 (f xβ) (g xβ)
h3xβ : xβ β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
hI :
DifferentiableWithinAt π (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g xβ))
hI' :
DifferentiableWithinAt π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f xβ (g xβ)))))
(range βI') (β(extChartAt I' (f xβ (g xβ))) (f xβ (g xβ)))
h3f : DifferentiableWithinAt π (writtenInExtChartAt I I' (g xβ) (f xβ)) (range βI) (β(extChartAt I (g xβ)) (g xβ))
β’ (β(extChartAt I (g xβ)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (β(extChartAt I (g xβ)) (g xβ)) =
β(extChartAt I (g xβ)) (g xβ)
[PROOFSTEP]
simp_rw [Function.comp_apply, (extChartAt I (g xβ)).left_inv hxβ]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒ² :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβΒΉ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))))
xβ
β’ ContMDiffAt J π(π, E βL[π] E') m
(inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ) xβ
[PROOFSTEP]
refine' this.congr_of_eventuallyEq _
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒ² :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβΒΉ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))))
xβ
β’ inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ =αΆ [π xβ] fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x))))
[PROOFSTEP]
filter_upwards [h2g, h4f] with x hx h2x
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒ² :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβΒΉ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))))
xβ
x : N
hx : x β g β»ΒΉ' (extChartAt I (g xβ)).source
h2x : x β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
β’ inTangentCoordinates I I' g (fun x => f x (g x)) (fun x => mfderiv I I' (f x) (g x)) xβ x =
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x))))
[PROOFSTEP]
rw [inTangentCoordinates_eq]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒ² :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβΒΉ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))))
xβ
x : N
hx : x β g β»ΒΉ' (extChartAt I (g xβ)).source
h2x : x β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
β’ ContinuousLinearMap.comp
(VectorBundleCore.coordChange (tangentBundleCore I' M') (achart H' (f x (g x))) (achart H' (f xβ (g xβ)))
(f x (g x)))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(VectorBundleCore.coordChange (tangentBundleCore I M) (achart H (g xβ)) (achart H (g x)) (g x))) =
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x))))
[PROOFSTEP]
rfl
[GOAL]
case h.hx
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒ² :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβΒΉ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))))
xβ
x : N
hx : x β g β»ΒΉ' (extChartAt I (g xβ)).source
h2x : x β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
β’ g x β (chartAt H (g xβ)).toLocalEquiv.source
[PROOFSTEP]
rwa [extChartAt_source] at hx
[GOAL]
case h.hy
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
xβ : N
f : N β M β M'
g : N β M
hf : ContMDiffAt (ModelWithCorners.prod J I) I' n (uncurry f) (xβ, g xβ)
hg : ContMDiffAt J I m g xβ
hmn : m + 1 β€ n
h4fβ : ContinuousAt (fun x => f x (g x)) xβ
h4f : (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source β π xβ
h3f : βαΆ (x' : N Γ M) in π (xβ, g xβ), ContMDiffAt (ModelWithCorners.prod J I) I' (βOne.one) (uncurry f) x'
h2f : βαΆ (xβ : N) in π xβ, ContMDiffAt I I' 1 (f xβ) (g xβ)
h2g : g β»ΒΉ' (extChartAt I (g xβ)).source β π xβ
thisβΒ² :
ContDiffWithinAt π m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
f (β(LocalEquiv.symm (extChartAt J xβ)) x) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g (β(LocalEquiv.symm (extChartAt J xβ)) x))))
(range βJ) (β(extChartAt J xβ) xβ)
thisβΒΉ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β f x β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))
xβ
thisβ :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
fderivWithin π
(β(extChartAt I' (f xβ (g xβ))) β
β(LocalEquiv.symm (extChartAt I' (f x (g x)))) β
writtenInExtChartAt I I' (g x) (f x) β β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ))))
(range βI) (β(extChartAt I (g xβ)) (g x)))
xβ
_instβ : (x : N) β NormedAddCommGroup (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedAddCommGroup E)
_inst : (x : N) β NormedSpace π (TangentSpace I (g x)) := fun x => inferInstanceAs (NormedSpace π E)
this :
ContMDiffAt J π(π, E βL[π] E') m
(fun x =>
ContinuousLinearMap.comp
(fderivWithin π (β(extChartAt I' (f xβ (g xβ))) β β(LocalEquiv.symm (extChartAt I' (f x (g x))))) (range βI')
(β(extChartAt I' (f x (g x))) (f x (g x))))
(ContinuousLinearMap.comp (mfderiv I I' (f x) (g x))
(fderivWithin π (β(extChartAt I (g x)) β β(LocalEquiv.symm (extChartAt I (g xβ)))) (range βI)
(β(extChartAt I (g xβ)) (g x)))))
xβ
x : N
hx : x β g β»ΒΉ' (extChartAt I (g xβ)).source
h2x : x β (fun x => f x (g x)) β»ΒΉ' (extChartAt I' (f xβ (g xβ))).source
β’ f x (g x) β (chartAt H' (f xβ (g xβ))).toLocalEquiv.source
[PROOFSTEP]
rwa [extChartAt_source] at h2x
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
β’ ContinuousOn (tangentMapWithin I I' f s) (TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
suffices h :
ContinuousOn
(fun p : H Γ E =>
(f p.fst,
(fderivWithin π (writtenInExtChartAt I I' p.fst f) (I.symm β»ΒΉ' s β© range I) ((extChartAt I p.fst) p.fst) :
E βL[π] E')
p.snd))
(Prod.fst β»ΒΉ' s)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
β’ ContinuousOn (tangentMapWithin I I' f s) (TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
have A := (tangentBundleModelSpaceHomeomorph H I).continuous
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : Continuous β(tangentBundleModelSpaceHomeomorph H I)
β’ ContinuousOn (tangentMapWithin I I' f s) (TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
rw [continuous_iff_continuousOn_univ] at A
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
β’ ContinuousOn (tangentMapWithin I I' f s) (TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
have B := ((tangentBundleModelSpaceHomeomorph H' I').symm.continuous.comp_continuousOn h).comp' A
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s))
β’ ContinuousOn (tangentMapWithin I I' f s) (TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
have : univ β© tangentBundleModelSpaceHomeomorph H I β»ΒΉ' (Prod.fst β»ΒΉ' s) = Ο E(TangentSpace I) β»ΒΉ' s := by ext β¨x, vβ©;
simp only [mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s))
β’ univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
[PROOFSTEP]
ext β¨x, vβ©
[GOAL]
case h.mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s))
x : H
v : TangentSpace I x
β’ { proj := x, snd := v } β univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) β
{ proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
[PROOFSTEP]
simp only [mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s))
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
β’ ContinuousOn (tangentMapWithin I I' f s) (TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
rw [this] at B
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
β’ ContinuousOn (tangentMapWithin I I' f s) (TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
apply B.congr
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
β’ EqOn (tangentMapWithin I I' f s)
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
rintro β¨x, vβ© hx
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
x : H
v : TangentSpace I x
hx : { proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
β’ tangentMapWithin I I' f s { proj := x, snd := v } =
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
{ proj := x, snd := v }
[PROOFSTEP]
dsimp [tangentMapWithin]
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
x : H
v : TangentSpace I x
hx : { proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
β’ { proj := f x, snd := β(mfderivWithin I I' f s x) v } =
β(TotalSpace.toProd H' E').symm
(f x,
β(fderivWithin π
((βI' β β(chartAt H' (f x))) β f β β(LocalHomeomorph.symm (chartAt H x)) β β(ModelWithCorners.symm I))
(β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI (β(chartAt H x) x)))
v)
[PROOFSTEP]
ext
[GOAL]
case mk.proj
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
x : H
v : TangentSpace I x
hx : { proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
β’ { proj := f x, snd := β(mfderivWithin I I' f s x) v }.proj =
(β(TotalSpace.toProd H' E').symm
(f x,
β(fderivWithin π
((βI' β β(chartAt H' (f x))) β f β β(LocalHomeomorph.symm (chartAt H x)) β β(ModelWithCorners.symm I))
(β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI (β(chartAt H x) x)))
v)).proj
[PROOFSTEP]
rfl
[GOAL]
case mk.snd
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
x : H
v : TangentSpace I x
hx : { proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
β’ HEq { proj := f x, snd := β(mfderivWithin I I' f s x) v }.snd
(β(TotalSpace.toProd H' E').symm
(f x,
β(fderivWithin π
((βI' β β(chartAt H' (f x))) β f β β(LocalHomeomorph.symm (chartAt H x)) β β(ModelWithCorners.symm I))
(β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI (β(chartAt H x) x)))
v)).snd
[PROOFSTEP]
simp only [mfld_simps]
[GOAL]
case mk.snd
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
x : H
v : TangentSpace I x
hx : { proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
β’ β(mfderivWithin I I' f s x) v =
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI x)) v
[PROOFSTEP]
apply congr_fun
[GOAL]
case mk.snd.h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
x : H
v : TangentSpace I x
hx : { proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
β’ β(mfderivWithin I I' f s x) = fun v =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI x)) v
[PROOFSTEP]
apply congr_arg
[GOAL]
case mk.snd.h.h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
x : H
v : TangentSpace I x
hx : { proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
β’ mfderivWithin I I' f s x =
fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI x)
[PROOFSTEP]
rw [MDifferentiableWithinAt.mfderivWithin (hf.mdifferentiableOn hn x hx)]
[GOAL]
case mk.snd.h.h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
A : ContinuousOn (β(tangentBundleModelSpaceHomeomorph H I)) univ
B :
ContinuousOn
((β(Homeomorph.symm (tangentBundleModelSpaceHomeomorph H' I')) β fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd)) β
β(tangentBundleModelSpaceHomeomorph H I))
(TotalSpace.proj β»ΒΉ' s)
this : univ β© β(tangentBundleModelSpaceHomeomorph H I) β»ΒΉ' (Prod.fst β»ΒΉ' s) = TotalSpace.proj β»ΒΉ' s
x : H
v : TangentSpace I x
hx : { proj := x, snd := v } β TotalSpace.proj β»ΒΉ' s
β’ fderivWithin π (writtenInExtChartAt I I' x f) (β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' s β© range βI)
(β(extChartAt I x) x) =
fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI x)
[PROOFSTEP]
rfl
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
β’ ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
suffices h :
ContinuousOn
(fun p : H Γ E => (fderivWithin π (I' β f β I.symm) (I.symm β»ΒΉ' s β© range I) (I p.fst) : E βL[π] E') p.snd)
(Prod.fst β»ΒΉ' s)
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst))
p.snd)
(Prod.fst β»ΒΉ' s)
β’ ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π (writtenInExtChartAt I I' p.fst f) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
(β(extChartAt I p.fst) p.fst))
p.snd))
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
dsimp [writtenInExtChartAt, extChartAt]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst))
p.snd)
(Prod.fst β»ΒΉ' s)
β’ ContinuousOn
(fun p =>
(f p.fst,
β(fderivWithin π
((βI' β β(chartAt H' (f p.fst))) β
f β β(LocalHomeomorph.symm (chartAt H p.fst)) β β(ModelWithCorners.symm I))
(β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI (β(chartAt H p.fst) p.fst)))
p.snd))
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
exact (ContinuousOn.comp hf.continuousOn continuous_fst.continuousOn Subset.rfl).prod h
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
β’ ContinuousOn
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst))
p.snd)
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
suffices h : ContinuousOn (fderivWithin π (I' β f β I.symm) (I.symm β»ΒΉ' s β© range I)) (I '' s)
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
β’ ContinuousOn
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst))
p.snd)
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
have C := ContinuousOn.comp h I.continuous_toFun.continuousOn Subset.rfl
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
C :
ContinuousOn
(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) β
βI.toLocalEquiv)
fun x => (βI '' s) (βI.toLocalEquiv x)
β’ ContinuousOn
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst))
p.snd)
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
have A : Continuous fun q : (E βL[π] E') Γ E => q.1 q.2 := isBoundedBilinearMapApply.continuous
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
C :
ContinuousOn
(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) β
βI.toLocalEquiv)
fun x => (βI '' s) (βI.toLocalEquiv x)
A : Continuous fun q => βq.fst q.snd
β’ ContinuousOn
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst))
p.snd)
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
have B :
ContinuousOn (fun p : H Γ E => (fderivWithin π (I' β f β I.symm) (I.symm β»ΒΉ' s β© range I) (I p.1), p.2))
(Prod.fst β»ΒΉ' s) :=
by
apply ContinuousOn.prod _ continuous_snd.continuousOn
refine C.comp continuousOn_fst ?_
exact preimage_mono (subset_preimage_image _ _)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
C :
ContinuousOn
(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) β
βI.toLocalEquiv)
fun x => (βI '' s) (βI.toLocalEquiv x)
A : Continuous fun q => βq.fst q.snd
β’ ContinuousOn
(fun p =>
(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst),
p.snd))
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
apply ContinuousOn.prod _ continuous_snd.continuousOn
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
C :
ContinuousOn
(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) β
βI.toLocalEquiv)
fun x => (βI '' s) (βI.toLocalEquiv x)
A : Continuous fun q => βq.fst q.snd
β’ ContinuousOn
(fun x =>
fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI x.fst))
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
refine C.comp continuousOn_fst ?_
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
C :
ContinuousOn
(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) β
βI.toLocalEquiv)
fun x => (βI '' s) (βI.toLocalEquiv x)
A : Continuous fun q => βq.fst q.snd
β’ MapsTo (fun x => x.fst) (Prod.fst β»ΒΉ' s) fun x => (βI '' s) (βI.toLocalEquiv x)
[PROOFSTEP]
exact preimage_mono (subset_preimage_image _ _)
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
h :
ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
C :
ContinuousOn
(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) β
βI.toLocalEquiv)
fun x => (βI '' s) (βI.toLocalEquiv x)
A : Continuous fun q => βq.fst q.snd
B :
ContinuousOn
(fun p =>
(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst),
p.snd))
(Prod.fst β»ΒΉ' s)
β’ ContinuousOn
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) (βI p.fst))
p.snd)
(Prod.fst β»ΒΉ' s)
[PROOFSTEP]
exact A.comp_continuousOn B
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hn : 1 β€ n
hs : UniqueMDiffOn I s
β’ ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
[PROOFSTEP]
rw [contMDiffOn_iff] at hf
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hn : 1 β€ n
hs : UniqueMDiffOn I s
β’ ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
[PROOFSTEP]
let x : H := I.symm (0 : E)
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hn : 1 β€ n
hs : UniqueMDiffOn I s
x : H := β(ModelWithCorners.symm I) 0
β’ ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
[PROOFSTEP]
let y : H' := I'.symm (0 : E')
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hn : 1 β€ n
hs : UniqueMDiffOn I s
x : H := β(ModelWithCorners.symm I) 0
y : H' := β(ModelWithCorners.symm I') 0
β’ ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
[PROOFSTEP]
have A := hf.2 x y
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hn : 1 β€ n
hs : UniqueMDiffOn I s
x : H := β(ModelWithCorners.symm I) 0
y : H' := β(ModelWithCorners.symm I') 0
A :
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
β’ ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(βI '' s)
[PROOFSTEP]
simp only [I.image_eq, inter_comm, mfld_simps] at A β’
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hn : 1 β€ n
hs : UniqueMDiffOn I s
x : H := β(ModelWithCorners.symm I) 0
y : H' := β(ModelWithCorners.symm I') 0
A : ContDiffOn π n (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
β’ ContinuousOn (fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI))
(β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
[PROOFSTEP]
apply A.continuousOn_fderivWithin _ hn
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hn : 1 β€ n
hs : UniqueMDiffOn I s
x : H := β(ModelWithCorners.symm I) 0
y : H' := β(ModelWithCorners.symm I') 0
A : ContDiffOn π n (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
β’ UniqueDiffOn π (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
[PROOFSTEP]
convert hs.uniqueDiffOn_target_inter x using 1
[GOAL]
case h.e'_7
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hn : 1 β€ n
hs : UniqueMDiffOn I s
x : H := β(ModelWithCorners.symm I) 0
y : H' := β(ModelWithCorners.symm I') 0
A : ContDiffOn π n (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI)
β’ β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI = (extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' s
[PROOFSTEP]
simp only [inter_comm, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
have m_le_n : m β€ n := (le_add_right le_rfl).trans hmn
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
have one_le_n : 1 β€ n := (le_add_left le_rfl).trans hmn
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
have U' : UniqueDiffOn π (range I β© I.symm β»ΒΉ' s) := fun y hy β¦ by
simpa only [UniqueMDiffOn, UniqueMDiffWithinAt, hy.1, inter_comm, mfld_simps] using hs (I.symm y) hy.2
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
y : E
hy : y β range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s
β’ UniqueDiffWithinAt π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) y
[PROOFSTEP]
simpa only [UniqueMDiffOn, UniqueMDiffWithinAt, hy.1, inter_comm, mfld_simps] using hs (I.symm y) hy.2
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
rw [contMDiffOn_iff]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
β’ ContinuousOn (tangentMapWithin I I' f s) (TotalSpace.proj β»ΒΉ' s) β§
β (x : TangentBundle I H) (y : TangentBundle I' H'),
ContDiffOn π m
(β(extChartAt (ModelWithCorners.tangent I') y) β
tangentMapWithin I I' f s β β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) x)))
((extChartAt (ModelWithCorners.tangent I) x).target β©
β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) x)) β»ΒΉ'
(TotalSpace.proj β»ΒΉ' s β© tangentMapWithin I I' f s β»ΒΉ' (extChartAt (ModelWithCorners.tangent I') y).source))
[PROOFSTEP]
refine' β¨hf.continuousOn_tangentMapWithin_aux one_le_n hs, fun p q => _β©
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
β’ ContDiffOn π m
(β(extChartAt (ModelWithCorners.tangent I') q) β
tangentMapWithin I I' f s β β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) p)))
((extChartAt (ModelWithCorners.tangent I) p).target β©
β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) p)) β»ΒΉ'
(TotalSpace.proj β»ΒΉ' s β© tangentMapWithin I I' f s β»ΒΉ' (extChartAt (ModelWithCorners.tangent I') q).source))
[PROOFSTEP]
suffices h :
ContDiffOn π m
(((fun p : H' Γ E' => (I' p.fst, p.snd)) β TotalSpace.toProd H' E') β
tangentMapWithin I I' f s β (TotalSpace.toProd H E).symm β fun p : E Γ E => (I.symm p.fst, p.snd))
((range I β© I.symm β»ΒΉ' s) ΓΛ’ univ)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
h :
ContDiffOn π m
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ ContDiffOn π m
(β(extChartAt (ModelWithCorners.tangent I') q) β
tangentMapWithin I I' f s β β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) p)))
((extChartAt (ModelWithCorners.tangent I) p).target β©
β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) p)) β»ΒΉ'
(TotalSpace.proj β»ΒΉ' s β© tangentMapWithin I I' f s β»ΒΉ' (extChartAt (ModelWithCorners.tangent I') q).source))
[PROOFSTEP]
convert h using 1
[GOAL]
case h.e'_10
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
h :
ContDiffOn π m
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ β(extChartAt (ModelWithCorners.tangent I') q) β
tangentMapWithin I I' f s β β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) p)) =
((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd)
[PROOFSTEP]
ext1 β¨x, yβ©
[GOAL]
case h.e'_10.h.mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
h :
ContDiffOn π m
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
x y : E
β’ (β(extChartAt (ModelWithCorners.tangent I') q) β
tangentMapWithin I I' f s β β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) p)))
(x, y) =
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
(x, y)
[PROOFSTEP]
simp only [mfld_simps]
[GOAL]
case h.e'_10.h.mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
xβ : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
h :
ContDiffOn π m
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
x y : E
β’ (βI'
(β(TotalSpace.toProd H' E')
(tangentMapWithin I I' f s
(β(TotalSpace.toProd H E).symm
(β(LocalEquiv.symm (LocalEquiv.prod I.toLocalEquiv (LocalEquiv.refl E))) (x, y))))).fst,
(β(TotalSpace.toProd H' E')
(tangentMapWithin I I' f s
(β(TotalSpace.toProd H E).symm
(β(LocalEquiv.symm (LocalEquiv.prod I.toLocalEquiv (LocalEquiv.refl E))) (x, y))))).snd) =
(βI' (f (β(ModelWithCorners.symm I) x)),
(tangentMapWithin I I' f s (β(TotalSpace.toProd H E).symm (β(ModelWithCorners.symm I) x, y))).snd)
[PROOFSTEP]
rfl
[GOAL]
case h.e'_11
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
h :
ContDiffOn π m
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ (extChartAt (ModelWithCorners.tangent I) p).target β©
β(LocalEquiv.symm (extChartAt (ModelWithCorners.tangent I) p)) β»ΒΉ'
(TotalSpace.proj β»ΒΉ' s β© tangentMapWithin I I' f s β»ΒΉ' (extChartAt (ModelWithCorners.tangent I') q).source) =
(range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ
[PROOFSTEP]
simp only [mfld_simps]
[GOAL]
case h.e'_11
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
h :
ContDiffOn π m
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ range βI ΓΛ’ univ β©
β(TotalSpace.toProd H E).symm β β(LocalEquiv.symm (LocalEquiv.prod I.toLocalEquiv (LocalEquiv.refl E))) β»ΒΉ'
(TotalSpace.proj β»ΒΉ' s) =
(range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ
[PROOFSTEP]
rw [inter_prod, prod_univ, prod_univ]
[GOAL]
case h.e'_11
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
h :
ContDiffOn π m
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ Prod.fst β»ΒΉ' range βI β©
β(TotalSpace.toProd H E).symm β β(LocalEquiv.symm (LocalEquiv.prod I.toLocalEquiv (LocalEquiv.refl E))) β»ΒΉ'
(TotalSpace.proj β»ΒΉ' s) =
Prod.fst β»ΒΉ' range βI β© Prod.fst β»ΒΉ' (β(ModelWithCorners.symm I) β»ΒΉ' s)
[PROOFSTEP]
rfl
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
β’ ContDiffOn π m
(((fun p => (βI' p.fst, p.snd)) β β(TotalSpace.toProd H' E')) β
tangentMapWithin I I' f s β β(TotalSpace.toProd H E).symm β fun p => (β(ModelWithCorners.symm I) p.fst, p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
change
ContDiffOn π m
(fun p : E Γ E => ((I' (f (I.symm p.fst)), (mfderivWithin I I' f s (I.symm p.fst) : E β E') p.snd) : E' Γ E'))
((range I β© I.symm β»ΒΉ' s) ΓΛ’ univ)
-- check that all bits in this formula are `C^n`
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
β’ ContDiffOn π m
(fun p =>
(βI' (f (β(ModelWithCorners.symm I) p.fst)), β(mfderivWithin I I' f s (β(ModelWithCorners.symm I) p.fst)) p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
have hf' := contMDiffOn_iff.1 hf
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
β’ ContDiffOn π m
(fun p =>
(βI' (f (β(ModelWithCorners.symm I) p.fst)), β(mfderivWithin I I' f s (β(ModelWithCorners.symm I) p.fst)) p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
have A : ContDiffOn π m (I' β f β I.symm) (range I β© I.symm β»ΒΉ' s) := by
simpa only [mfld_simps] using (hf'.2 (I.symm 0) (I'.symm 0)).of_le m_le_n
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
β’ ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
[PROOFSTEP]
simpa only [mfld_simps] using (hf'.2 (I.symm 0) (I'.symm 0)).of_le m_le_n
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
β’ ContDiffOn π m
(fun p =>
(βI' (f (β(ModelWithCorners.symm I) p.fst)), β(mfderivWithin I I' f s (β(ModelWithCorners.symm I) p.fst)) p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
have B : ContDiffOn π m ((I' β f β I.symm) β Prod.fst) ((range I β© I.symm β»ΒΉ' s) ΓΛ’ (univ : Set E)) :=
A.comp contDiff_fst.contDiffOn (prod_subset_preimage_fst _ _)
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ ContDiffOn π m
(fun p =>
(βI' (f (β(ModelWithCorners.symm I) p.fst)), β(mfderivWithin I I' f s (β(ModelWithCorners.symm I) p.fst)) p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
suffices C :
ContDiffOn π m (fun p : E Γ E => (fderivWithin π (I' β f β I.symm) (I.symm β»ΒΉ' s β© range I) p.1 : _) p.2)
((range I β© I.symm β»ΒΉ' s) ΓΛ’ (univ : Set E))
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
C :
ContDiffOn π m
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst)
p.snd)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ ContDiffOn π m
(fun p =>
(βI' (f (β(ModelWithCorners.symm I) p.fst)), β(mfderivWithin I I' f s (β(ModelWithCorners.symm I) p.fst)) p.snd))
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
refine ContDiffOn.prod B ?_
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
C :
ContDiffOn π m
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst)
p.snd)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ ContDiffOn π m (fun p => β(mfderivWithin I I' f s (β(ModelWithCorners.symm I) p.fst)) p.snd)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
refine C.congr fun p hp => ?_
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
pβ : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
C :
ContDiffOn π m
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst)
p.snd)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
p : E Γ E
hp : p β (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ
β’ β(mfderivWithin I I' f s (β(ModelWithCorners.symm I) p.fst)) p.snd =
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst) p.snd
[PROOFSTEP]
simp only [mfld_simps] at hp
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
pβ : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
C :
ContDiffOn π m
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst)
p.snd)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
p : E Γ E
hp : p.fst β range βI β§ β(ModelWithCorners.symm I) p.fst β s
β’ β(mfderivWithin I I' f s (β(ModelWithCorners.symm I) p.fst)) p.snd =
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst) p.snd
[PROOFSTEP]
simp only [mfderivWithin, hf.mdifferentiableOn one_le_n _ hp.2, hp.1, if_pos, mfld_simps]
[GOAL]
case C
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ ContDiffOn π m
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst)
p.snd)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
have D :
ContDiffOn π m (fun x => fderivWithin π (I' β f β I.symm) (I.symm β»ΒΉ' s β© range I) x) (range I β© I.symm β»ΒΉ' s) :=
by
have : ContDiffOn π n (I' β f β I.symm) (range I β© I.symm β»ΒΉ' s) := by
simpa only [mfld_simps] using hf'.2 (I.symm 0) (I'.symm 0)
simpa only [inter_comm] using this.fderivWithin U' hmn
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ ContDiffOn π m
(fun x => fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) x)
(range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
[PROOFSTEP]
have : ContDiffOn π n (I' β f β I.symm) (range I β© I.symm β»ΒΉ' s) := by
simpa only [mfld_simps] using hf'.2 (I.symm 0) (I'.symm 0)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
β’ ContDiffOn π n (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
[PROOFSTEP]
simpa only [mfld_simps] using hf'.2 (I.symm 0) (I'.symm 0)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
this : ContDiffOn π n (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
β’ ContDiffOn π m
(fun x => fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) x)
(range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
[PROOFSTEP]
simpa only [inter_comm] using this.fderivWithin U' hmn
[GOAL]
case C
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
D :
ContDiffOn π m
(fun x => fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) x)
(range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
β’ ContDiffOn π m
(fun p =>
β(fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst)
p.snd)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
refine ContDiffOn.clm_apply ?_ contDiffOn_snd
[GOAL]
case C
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
fβ fβ : M β M'
sβ sβ t : Set M
x : M
m n : ββ
f : H β H'
s : Set H
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
m_le_n : m β€ n
one_le_n : 1 β€ n
U' : UniqueDiffOn π (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
p : TangentBundle I H
q : TangentBundle I' H'
hf' :
ContinuousOn f s β§
β (x : H) (y : H'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
A : ContDiffOn π m (βI' β f β β(ModelWithCorners.symm I)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
B :
ContDiffOn π m ((βI' β f β β(ModelWithCorners.symm I)) β Prod.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
D :
ContDiffOn π m
(fun x => fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) x)
(range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s)
β’ ContDiffOn π m
(fun p => fderivWithin π (βI' β f β β(ModelWithCorners.symm I)) (β(ModelWithCorners.symm I) β»ΒΉ' s β© range βI) p.fst)
((range βI β© β(ModelWithCorners.symm I) β»ΒΉ' s) ΓΛ’ univ)
[PROOFSTEP]
exact D.comp contDiff_fst.contDiffOn (prod_subset_preimage_fst _ _)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
have one_le_n : 1 β€ n := (le_add_left le_rfl).trans hmn
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s)
[PROOFSTEP]
refine' contMDiffOn_of_locally_contMDiffOn fun p hp => _
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hp : p β TotalSpace.proj β»ΒΉ' s
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
have hf' := contMDiffOn_iff.1 hf
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hp : p β TotalSpace.proj β»ΒΉ' s
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
simp only [mfld_simps] at hp
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let l := chartAt H p.proj
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
set Dl := chartAt (ModelProd H E) p with hDl
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let r := chartAt H' (f p.proj)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let Dr := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let il := chartAt (ModelProd H E) (tangentMap I I l p)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let ir := chartAt (ModelProd H' E') (tangentMap I I' (r β f) p)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let s' := f β»ΒΉ' r.source β© s β© l.source
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let s'_lift := Ο E(TangentSpace I) β»ΒΉ' s'
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let s'l := l.target β© l.symm β»ΒΉ' s'
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
let s'l_lift := Ο E(TangentSpace I) β»ΒΉ' s'l
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
rcases continuousOn_iff'.1 hf'.1 r.source r.open_source with β¨o, o_open, hoβ©
[GOAL]
case intro.intro
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
suffices h : ContMDiffOn I.tangent I'.tangent m (tangentMapWithin I I' f s) s'_lift
[GOAL]
case intro.intro
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ β u,
IsOpen u β§
p β u β§
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© u)
[PROOFSTEP]
refine' β¨Ο E(TangentSpace I) β»ΒΉ' (o β© l.source), _, _, _β©
[GOAL]
case intro.intro.refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ IsOpen (TotalSpace.proj β»ΒΉ' (o β© l.source))
case intro.intro.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ p β TotalSpace.proj β»ΒΉ' (o β© l.source)
case intro.intro.refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© l.source))
[PROOFSTEP]
show IsOpen (Ο E(TangentSpace I) β»ΒΉ' (o β© l.source))
[GOAL]
case intro.intro.refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ IsOpen (TotalSpace.proj β»ΒΉ' (o β© l.source))
case intro.intro.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ p β TotalSpace.proj β»ΒΉ' (o β© l.source)
case intro.intro.refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© l.source))
[PROOFSTEP]
exact (IsOpen.inter o_open l.open_source).preimage (FiberBundle.continuous_proj E _)
[GOAL]
case intro.intro.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ p β TotalSpace.proj β»ΒΉ' (o β© l.source)
case intro.intro.refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© l.source))
[PROOFSTEP]
show p β Ο E(TangentSpace I) β»ΒΉ' (o β© l.source)
[GOAL]
case intro.intro.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ p β TotalSpace.proj β»ΒΉ' (o β© l.source)
[PROOFSTEP]
simp
[GOAL]
case intro.intro.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ p.proj β o
[PROOFSTEP]
have : p.proj β f β»ΒΉ' r.source β© s := by simp [hp]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ p.proj β f β»ΒΉ' r.source β© s
[PROOFSTEP]
simp [hp]
[GOAL]
case intro.intro.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
this : p.proj β f β»ΒΉ' r.source β© s
β’ p.proj β o
[PROOFSTEP]
rw [ho] at this
[GOAL]
case intro.intro.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
this : p.proj β o β© s
β’ p.proj β o
[PROOFSTEP]
exact this.1
[GOAL]
case intro.intro.refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© l.source))
[PROOFSTEP]
have : Ο E(TangentSpace I) β»ΒΉ' s β© Ο E(TangentSpace I) β»ΒΉ' (o β© l.source) = s'_lift := by dsimp only; rw [ho];
mfld_set_tac
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© l.source) = s'_lift
[PROOFSTEP]
dsimp only
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© (chartAt H p.proj).toLocalEquiv.source) =
TotalSpace.proj β»ΒΉ' (f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source)
[PROOFSTEP]
rw [ho]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
β’ TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© (chartAt H p.proj).toLocalEquiv.source) =
TotalSpace.proj β»ΒΉ' (o β© s β© (chartAt H p.proj).toLocalEquiv.source)
[PROOFSTEP]
mfld_set_tac
[GOAL]
case intro.intro.refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
this : TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© l.source) = s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s)
(TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© l.source))
[PROOFSTEP]
rw [this]
[GOAL]
case intro.intro.refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
h : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
this : TotalSpace.proj β»ΒΉ' s β© TotalSpace.proj β»ΒΉ' (o β© l.source) = s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
exact h
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have U' : UniqueMDiffOn I s' := by
apply UniqueMDiffOn.inter _ l.open_source
rw [ho, inter_comm]
exact hs.inter o_open
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
β’ UniqueMDiffOn I s'
[PROOFSTEP]
apply UniqueMDiffOn.inter _ l.open_source
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
β’ UniqueMDiffOn I (f β»ΒΉ' r.source β© s)
[PROOFSTEP]
rw [ho, inter_comm]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
β’ UniqueMDiffOn I (s β© o)
[PROOFSTEP]
exact hs.inter o_open
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have U'l : UniqueMDiffOn I s'l := U'.uniqueMDiffOn_preimage (mdifferentiable_chart _ _)
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_f : ContMDiffOn I I' n f s' := hf.mono (by mfld_set_tac)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
β’ s' β s
[PROOFSTEP]
mfld_set_tac
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_r : ContMDiffOn I' I' n r r.source := contMDiffOn_chart
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_rf : ContMDiffOn I I' n (r β f) s' :=
by
refine ContMDiffOn.comp diff_r diff_f fun x hx => ?_
simp only [mfld_simps] at hx ; simp only [hx, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
β’ ContMDiffOn I I' n (βr β f) s'
[PROOFSTEP]
refine ContMDiffOn.comp diff_r diff_f fun x hx => ?_
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
x : M
hx : x β s'
β’ x β f β»ΒΉ' r.source
[PROOFSTEP]
simp only [mfld_simps] at hx
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
x : M
hx : (f x β (chartAt H' (f p.proj)).toLocalEquiv.source β§ x β s) β§ x β (chartAt H p.proj).toLocalEquiv.source
β’ x β f β»ΒΉ' r.source
[PROOFSTEP]
simp only [hx, mfld_simps]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_l : ContMDiffOn I I n l.symm s'l :=
haveI A : ContMDiffOn I I n l.symm l.target := contMDiffOn_chart_symm
A.mono (by mfld_set_tac)
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
A : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) l.target
β’ s'l β l.target
[PROOFSTEP]
mfld_set_tac
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_rfl : ContMDiffOn I I' n (r β f β l.symm) s'l :=
by
apply ContMDiffOn.comp diff_rf diff_l
mfld_set_tac
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
β’ ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
[PROOFSTEP]
apply ContMDiffOn.comp diff_rf diff_l
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
β’ s'l β β(LocalHomeomorph.symm l) β»ΒΉ' s'
[PROOFSTEP]
mfld_set_tac
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_rfl_lift : ContMDiffOn I.tangent I'.tangent m (tangentMapWithin I I' (r β f β l.symm) s'l) s'l_lift :=
diff_rfl.contMDiffOn_tangentMapWithin_aux hmn U'l
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_irrfl_lift : ContMDiffOn I.tangent I'.tangent m (ir β tangentMapWithin I I' (r β f β l.symm) s'l) s'l_lift :=
haveI A : ContMDiffOn I'.tangent I'.tangent m ir ir.source := contMDiffOn_chart
ContMDiffOn.comp A diff_rfl_lift fun p _ => by simp only [mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I') (ModelWithCorners.tangent I') m (βir) ir.source
p : TangentBundle I H
xβ : p β s'l_lift
β’ p β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β»ΒΉ' ir.source
[PROOFSTEP]
simp only [mfld_simps]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_Drirrfl_lift :
ContMDiffOn I.tangent I'.tangent m (Dr.symm β ir β tangentMapWithin I I' (r β f β l.symm) s'l) s'l_lift :=
by
have A : ContMDiffOn I'.tangent I'.tangent m Dr.symm Dr.target := contMDiffOn_chart_symm
refine ContMDiffOn.comp A diff_irrfl_lift fun p hp => ?_
simp only [mfld_simps] at hp
rw [mem_preimage, TangentBundle.mem_chart_target_iff]
simp only [hp, mfld_simps]
-- conclusion of this step: the composition of all the maps above is smooth
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
[PROOFSTEP]
have A : ContMDiffOn I'.tangent I'.tangent m Dr.symm Dr.target := contMDiffOn_chart_symm
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I') (ModelWithCorners.tangent I') m (β(LocalHomeomorph.symm Dr)) Dr.target
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
[PROOFSTEP]
refine ContMDiffOn.comp A diff_irrfl_lift fun p hp => ?_
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I') (ModelWithCorners.tangent I') m (β(LocalHomeomorph.symm Dr)) Dr.target
p : TangentBundle I H
hp : p β s'l_lift
β’ p β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β»ΒΉ' Dr.target
[PROOFSTEP]
simp only [mfld_simps] at hp
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I') (ModelWithCorners.tangent I') m (β(LocalHomeomorph.symm Dr)) Dr.target
p : TangentBundle I H
hp :
p.proj β (chartAt H pβ.proj).toLocalEquiv.target β§
(f (β(LocalHomeomorph.symm (chartAt H pβ.proj)) p.proj) β (chartAt H' (f pβ.proj)).toLocalEquiv.source β§
β(LocalHomeomorph.symm (chartAt H pβ.proj)) p.proj β s) β§
β(LocalHomeomorph.symm (chartAt H pβ.proj)) p.proj β (chartAt H pβ.proj).toLocalEquiv.source
β’ p β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β»ΒΉ' Dr.target
[PROOFSTEP]
rw [mem_preimage, TangentBundle.mem_chart_target_iff]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I') (ModelWithCorners.tangent I') m (β(LocalHomeomorph.symm Dr)) Dr.target
p : TangentBundle I H
hp :
p.proj β (chartAt H pβ.proj).toLocalEquiv.target β§
(f (β(LocalHomeomorph.symm (chartAt H pβ.proj)) p.proj) β (chartAt H' (f pβ.proj)).toLocalEquiv.source β§
β(LocalHomeomorph.symm (chartAt H pβ.proj)) p.proj β s) β§
β(LocalHomeomorph.symm (chartAt H pβ.proj)) p.proj β (chartAt H pβ.proj).toLocalEquiv.source
β’ ((βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) p).fst β
(chartAt H' (tangentMapWithin I I' f s pβ).proj).toLocalEquiv.target
[PROOFSTEP]
simp only [hp, mfld_simps]
-- conclusion of this step: the composition of all the maps above is smooth
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have diff_DrirrflilDl :
ContMDiffOn I.tangent I'.tangent m (Dr.symm β (ir β tangentMapWithin I I' (r β f β l.symm) s'l) β il.symm β Dl)
s'_lift :=
by
have A : ContMDiffOn I.tangent I.tangent m Dl Dl.source := contMDiffOn_chart
have A' : ContMDiffOn I.tangent I.tangent m Dl s'_lift :=
by
refine A.mono fun p hp => ?_
simp only [mfld_simps] at hp
simp only [hp, mfld_simps]
have B : ContMDiffOn I.tangent I.tangent m il.symm il.target := contMDiffOn_chart_symm
have C : ContMDiffOn I.tangent I.tangent m (il.symm β Dl) s'_lift :=
ContMDiffOn.comp B A' fun p _ => by simp only [mfld_simps]
refine diff_Drirrfl_lift.comp C fun p hp => ?_
simp only [mfld_simps] at hp
simp only [hp, TotalSpace.proj, mfld_simps]
/- Third step: check that the composition of all the maps indeed coincides with the derivative we
are looking for -/
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
[PROOFSTEP]
have A : ContMDiffOn I.tangent I.tangent m Dl Dl.source := contMDiffOn_chart
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
[PROOFSTEP]
have A' : ContMDiffOn I.tangent I.tangent m Dl s'_lift :=
by
refine A.mono fun p hp => ?_
simp only [mfld_simps] at hp
simp only [hp, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) s'_lift
[PROOFSTEP]
refine A.mono fun p hp => ?_
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
p : TangentBundle I M
hp : p β s'_lift
β’ p β Dl.source
[PROOFSTEP]
simp only [mfld_simps] at hp
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
p : TangentBundle I M
hp :
(f p.proj β (chartAt H' (f pβ.proj)).toLocalEquiv.source β§ p.proj β s) β§
p.proj β (chartAt H pβ.proj).toLocalEquiv.source
β’ p β Dl.source
[PROOFSTEP]
simp only [hp, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
A' : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
[PROOFSTEP]
have B : ContMDiffOn I.tangent I.tangent m il.symm il.target := contMDiffOn_chart_symm
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
A' : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) s'_lift
B : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (β(LocalHomeomorph.symm il)) il.target
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
[PROOFSTEP]
have C : ContMDiffOn I.tangent I.tangent m (il.symm β Dl) s'_lift :=
ContMDiffOn.comp B A' fun p _ => by simp only [mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
A' : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) s'_lift
B : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (β(LocalHomeomorph.symm il)) il.target
p : TangentBundle I M
xβ : p β s'_lift
β’ p β βDl β»ΒΉ' il.target
[PROOFSTEP]
simp only [mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
A' : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) s'_lift
B : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (β(LocalHomeomorph.symm il)) il.target
C : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (β(LocalHomeomorph.symm il) β βDl) s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
[PROOFSTEP]
refine diff_Drirrfl_lift.comp C fun p hp => ?_
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
A' : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) s'_lift
B : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (β(LocalHomeomorph.symm il)) il.target
C : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (β(LocalHomeomorph.symm il) β βDl) s'_lift
p : TangentBundle I M
hp : p β s'_lift
β’ p β (fun x => (β(LocalHomeomorph.symm il) β βDl) x) β»ΒΉ' s'l_lift
[PROOFSTEP]
simp only [mfld_simps] at hp
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
A : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) Dl.source
A' : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (βDl) s'_lift
B : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (β(LocalHomeomorph.symm il)) il.target
C : ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I) m (β(LocalHomeomorph.symm il) β βDl) s'_lift
p : TangentBundle I M
hp :
(f p.proj β (chartAt H' (f pβ.proj)).toLocalEquiv.source β§ p.proj β s) β§
p.proj β (chartAt H pβ.proj).toLocalEquiv.source
β’ p β (fun x => (β(LocalHomeomorph.symm il) β βDl) x) β»ΒΉ' s'l_lift
[PROOFSTEP]
simp only [hp, TotalSpace.proj, mfld_simps]
/- Third step: check that the composition of all the maps indeed coincides with the derivative we
are looking for -/
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
have eq_comp :
β q β s'_lift,
tangentMapWithin I I' f s q = (Dr.symm β ir β tangentMapWithin I I' (r β f β l.symm) s'l β il.symm β Dl) q :=
by
intro q hq
simp only [mfld_simps] at hq
have U'q : UniqueMDiffWithinAt I s' q.1 := by apply U'; simp only [hq, mfld_simps]
have U'lq : UniqueMDiffWithinAt I s'l (Dl q).1 := by apply U'l; simp only [hq, mfld_simps]
have A :
tangentMapWithin I I' ((r β f) β l.symm) s'l (il.symm (Dl q)) =
tangentMapWithin I I' (r β f) s' (tangentMapWithin I I l.symm s'l (il.symm (Dl q))) :=
by
refine' tangentMapWithin_comp_at (il.symm (Dl q)) _ _ (fun p hp => _) U'lq
Β· apply diff_rf.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
Β· apply diff_l.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
Β· simp only [mfld_simps] at hp ; simp only [hp, mfld_simps]
have B : tangentMapWithin I I l.symm s'l (il.symm (Dl q)) = q :=
by
have : tangentMapWithin I I l.symm s'l (il.symm (Dl q)) = tangentMap I I l.symm (il.symm (Dl q))
Β· refine'
tangentMapWithin_eq_tangentMap U'lq
_
-- Porting note: the arguments below were underscores.
refine' mdifferentiableAt_atlas_symm I (chart_mem_atlas H (TotalSpace.proj p)) _
simp only [hq, mfld_simps]
rw [this, tangentMap_chart_symm, hDl]
Β· simp only [hq, mfld_simps]
have : q β (chartAt (ModelProd H E) p).source := by simp only [hq, mfld_simps]
exact (chartAt (ModelProd H E) p).left_inv this
Β· simp only [hq, mfld_simps]
have C : tangentMapWithin I I' (r β f) s' q = tangentMapWithin I' I' r r.source (tangentMapWithin I I' f s' q) :=
by
refine' tangentMapWithin_comp_at q _ _ (fun r hr => _) U'q
Β· apply diff_r.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
Β· apply diff_f.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
Β· simp only [mfld_simps] at hr
simp only [hr, mfld_simps]
have D :
Dr.symm (ir (tangentMapWithin I' I' r r.source (tangentMapWithin I I' f s' q))) = tangentMapWithin I I' f s' q :=
by
have A :
tangentMapWithin I' I' r r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' r (tangentMapWithin I I' f s' q) :=
by
apply tangentMapWithin_eq_tangentMap
Β· apply IsOpen.uniqueMDiffWithinAt _ r.open_source; simp [hq]
Β· exact mdifferentiableAt_atlas I' (chart_mem_atlas H' (f p.proj)) hq.1.1
have : f p.proj = (tangentMapWithin I I' f s p).1 := rfl
rw [A]
dsimp
rw [this, tangentMap_chart]
Β· simp only [hq, mfld_simps]
have : tangentMapWithin I I' f s' q β (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)).source := by
simp only [hq, mfld_simps]
exact (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)).left_inv this
Β· simp only [hq, mfld_simps]
have E : tangentMapWithin I I' f s' q = tangentMapWithin I I' f s q :=
by
refine' tangentMapWithin_subset (by mfld_set_tac) U'q _
apply hf.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
dsimp only [(Β· β Β·)] at A B C D E β’
simp only [A, B, C, D, β E]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
β’ β (q : TotalSpace E (TangentSpace I)),
q β s'_lift β
tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
intro q hq
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq : q β s'_lift
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
simp only [mfld_simps] at hq
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
have U'q : UniqueMDiffWithinAt I s' q.1 := by apply U'; simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
β’ UniqueMDiffWithinAt I s' q.proj
[PROOFSTEP]
apply U'
[GOAL]
case a
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
β’ q.proj β s'
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
have U'lq : UniqueMDiffWithinAt I s'l (Dl q).1 := by apply U'l; simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
β’ UniqueMDiffWithinAt I s'l (βDl q).fst
[PROOFSTEP]
apply U'l
[GOAL]
case a
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
β’ (βDl q).fst β s'l
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
have A :
tangentMapWithin I I' ((r β f) β l.symm) s'l (il.symm (Dl q)) =
tangentMapWithin I I' (r β f) s' (tangentMapWithin I I l.symm s'l (il.symm (Dl q))) :=
by
refine' tangentMapWithin_comp_at (il.symm (Dl q)) _ _ (fun p hp => _) U'lq
Β· apply diff_rf.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
Β· apply diff_l.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
Β· simp only [mfld_simps] at hp ; simp only [hp, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
β’ tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
[PROOFSTEP]
refine' tangentMapWithin_comp_at (il.symm (Dl q)) _ _ (fun p hp => _) U'lq
[GOAL]
case refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
β’ MDifferentiableWithinAt I I' (βr β f) s' (β(LocalHomeomorph.symm l) (β(LocalHomeomorph.symm il) (βDl q)).proj)
[PROOFSTEP]
apply diff_rf.mdifferentiableOn one_le_n
[GOAL]
case refine'_1.a
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
β’ β(LocalHomeomorph.symm l) (β(LocalHomeomorph.symm il) (βDl q)).proj β s'
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
case refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
β’ MDifferentiableWithinAt I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)).proj
[PROOFSTEP]
apply diff_l.mdifferentiableOn one_le_n
[GOAL]
case refine'_2.a
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
β’ (β(LocalHomeomorph.symm il) (βDl q)).proj β s'l
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
case refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f pβ.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H pβ.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
p : H
hp : p β s'l
β’ p β β(LocalHomeomorph.symm l) β»ΒΉ' s'
[PROOFSTEP]
simp only [mfld_simps] at hp
[GOAL]
case refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
pβ : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hpβ : pβ.proj β s
l : LocalHomeomorph M H := chartAt H pβ.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) pβ
hDl : Dl = chartAt (ModelProd H E) pβ
r : LocalHomeomorph M' H' := chartAt H' (f pβ.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s pβ)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) pβ)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) pβ)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f pβ.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H pβ.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
p : H
hp :
p β (chartAt H pβ.proj).toLocalEquiv.target β§
(f (β(LocalHomeomorph.symm (chartAt H pβ.proj)) p) β (chartAt H' (f pβ.proj)).toLocalEquiv.source β§
β(LocalHomeomorph.symm (chartAt H pβ.proj)) p β s) β§
β(LocalHomeomorph.symm (chartAt H pβ.proj)) p β (chartAt H pβ.proj).toLocalEquiv.source
β’ p β β(LocalHomeomorph.symm l) β»ΒΉ' s'
[PROOFSTEP]
simp only [hp, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
have B : tangentMapWithin I I l.symm s'l (il.symm (Dl q)) = q :=
by
have : tangentMapWithin I I l.symm s'l (il.symm (Dl q)) = tangentMap I I l.symm (il.symm (Dl q))
Β· refine'
tangentMapWithin_eq_tangentMap U'lq
_
-- Porting note: the arguments below were underscores.
refine' mdifferentiableAt_atlas_symm I (chart_mem_atlas H (TotalSpace.proj p)) _
simp only [hq, mfld_simps]
rw [this, tangentMap_chart_symm, hDl]
Β· simp only [hq, mfld_simps]
have : q β (chartAt (ModelProd H E) p).source := by simp only [hq, mfld_simps]
exact (chartAt (ModelProd H E) p).left_inv this
Β· simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
β’ tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
[PROOFSTEP]
have : tangentMapWithin I I l.symm s'l (il.symm (Dl q)) = tangentMap I I l.symm (il.symm (Dl q))
[GOAL]
case this
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
β’ tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMap I I (β(LocalHomeomorph.symm l)) (β(LocalHomeomorph.symm il) (βDl q))
[PROOFSTEP]
refine'
tangentMapWithin_eq_tangentMap U'lq
_
-- Porting note: the arguments below were underscores.
[GOAL]
case this
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
β’ MDifferentiableAt I I (β(LocalHomeomorph.symm l)) (β(LocalHomeomorph.symm il) (βDl q)).proj
[PROOFSTEP]
refine' mdifferentiableAt_atlas_symm I (chart_mem_atlas H (TotalSpace.proj p)) _
[GOAL]
case this
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
β’ (β(LocalHomeomorph.symm il) (βDl q)).proj β (chartAt H p.proj).toLocalEquiv.target
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
this :
tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMap I I (β(LocalHomeomorph.symm l)) (β(LocalHomeomorph.symm il) (βDl q))
β’ tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
[PROOFSTEP]
rw [this, tangentMap_chart_symm, hDl]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
this :
tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMap I I (β(LocalHomeomorph.symm l)) (β(LocalHomeomorph.symm il) (βDl q))
β’ β(LocalHomeomorph.symm (chartAt (ModelProd H E) p))
(β(TotalSpace.toProd H E) (β(LocalHomeomorph.symm il) (β(chartAt (ModelProd H E) p) q))) =
q
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
this :
tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMap I I (β(LocalHomeomorph.symm l)) (β(LocalHomeomorph.symm il) (βDl q))
β’ β(LocalHomeomorph.symm (chartAt (ModelProd H E) p))
(β(chartAt H p.proj) q.proj, (β(chartAt (ModelProd H E) p) q).snd) =
q
[PROOFSTEP]
have : q β (chartAt (ModelProd H E) p).source := by simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
this :
tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMap I I (β(LocalHomeomorph.symm l)) (β(LocalHomeomorph.symm il) (βDl q))
β’ q β (chartAt (ModelProd H E) p).toLocalEquiv.source
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
thisβ :
tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMap I I (β(LocalHomeomorph.symm l)) (β(LocalHomeomorph.symm il) (βDl q))
this : q β (chartAt (ModelProd H E) p).toLocalEquiv.source
β’ β(LocalHomeomorph.symm (chartAt (ModelProd H E) p))
(β(chartAt H p.proj) q.proj, (β(chartAt (ModelProd H E) p) q).snd) =
q
[PROOFSTEP]
exact (chartAt (ModelProd H E) p).left_inv this
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
this :
tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMap I I (β(LocalHomeomorph.symm l)) (β(LocalHomeomorph.symm il) (βDl q))
β’ (β(LocalHomeomorph.symm il) (βDl q)).proj β (chartAt H p.proj).toLocalEquiv.target
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
have C : tangentMapWithin I I' (r β f) s' q = tangentMapWithin I' I' r r.source (tangentMapWithin I I' f s' q) :=
by
refine' tangentMapWithin_comp_at q _ _ (fun r hr => _) U'q
Β· apply diff_r.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
Β· apply diff_f.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
Β· simp only [mfld_simps] at hr
simp only [hr, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
β’ tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
[PROOFSTEP]
refine' tangentMapWithin_comp_at q _ _ (fun r hr => _) U'q
[GOAL]
case refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
β’ MDifferentiableWithinAt I' I' (βr) r.source (f q.proj)
[PROOFSTEP]
apply diff_r.mdifferentiableOn one_le_n
[GOAL]
case refine'_1.a
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
β’ f q.proj β r.source
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
case refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
β’ MDifferentiableWithinAt I I' f s' q.proj
[PROOFSTEP]
apply diff_f.mdifferentiableOn one_le_n
[GOAL]
case refine'_2.a
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
β’ q.proj β s'
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
case refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
rβ : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βrβ β f) p)
s' : Set M := f β»ΒΉ' rβ.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' rβ.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βrβ) rβ.source
diff_rf : ContMDiffOn I I' n (βrβ β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βrβ β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βrβ β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βrβ β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βrβ β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βrβ β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βrβ β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βrβ β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
r : M
hr : r β s'
β’ r β f β»ΒΉ' rβ.source
[PROOFSTEP]
simp only [mfld_simps] at hr
[GOAL]
case refine'_3
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
rβ : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βrβ β f) p)
s' : Set M := f β»ΒΉ' rβ.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' rβ.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βrβ) rβ.source
diff_rf : ContMDiffOn I I' n (βrβ β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βrβ β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βrβ β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βrβ β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βrβ β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βrβ β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βrβ β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βrβ β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
r : M
hr : (f r β (chartAt H' (f p.proj)).toLocalEquiv.source β§ r β s) β§ r β (chartAt H p.proj).toLocalEquiv.source
β’ r β f β»ΒΉ' rβ.source
[PROOFSTEP]
simp only [hr, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
have D :
Dr.symm (ir (tangentMapWithin I' I' r r.source (tangentMapWithin I I' f s' q))) = tangentMapWithin I I' f s' q :=
by
have A :
tangentMapWithin I' I' r r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' r (tangentMapWithin I I' f s' q) :=
by
apply tangentMapWithin_eq_tangentMap
Β· apply IsOpen.uniqueMDiffWithinAt _ r.open_source; simp [hq]
Β· exact mdifferentiableAt_atlas I' (chart_mem_atlas H' (f p.proj)) hq.1.1
have : f p.proj = (tangentMapWithin I I' f s p).1 := rfl
rw [A]
dsimp
rw [this, tangentMap_chart]
Β· simp only [hq, mfld_simps]
have : tangentMapWithin I I' f s' q β (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)).source := by
simp only [hq, mfld_simps]
exact (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)).left_inv this
Β· simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
β’ β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
[PROOFSTEP]
have A :
tangentMapWithin I' I' r r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' r (tangentMapWithin I I' f s' q) :=
by
apply tangentMapWithin_eq_tangentMap
Β· apply IsOpen.uniqueMDiffWithinAt _ r.open_source; simp [hq]
Β· exact mdifferentiableAt_atlas I' (chart_mem_atlas H' (f p.proj)) hq.1.1
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
β’ tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
[PROOFSTEP]
apply tangentMapWithin_eq_tangentMap
[GOAL]
case hs
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
β’ UniqueMDiffWithinAt I' r.source (tangentMapWithin I I' f s' q).proj
[PROOFSTEP]
apply IsOpen.uniqueMDiffWithinAt _ r.open_source
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
β’ (tangentMapWithin I I' f s' q).proj β r.source
[PROOFSTEP]
simp [hq]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
β’ MDifferentiableAt I' I' (βr) (tangentMapWithin I I' f s' q).proj
[PROOFSTEP]
exact mdifferentiableAt_atlas I' (chart_mem_atlas H' (f p.proj)) hq.1.1
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
β’ β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
[PROOFSTEP]
have : f p.proj = (tangentMapWithin I I' f s p).1 := rfl
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
this : f p.proj = (tangentMapWithin I I' f s p).proj
β’ β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
[PROOFSTEP]
rw [A]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
this : f p.proj = (tangentMapWithin I I' f s p).proj
β’ β(LocalHomeomorph.symm Dr) (βir (tangentMap I' I' (βr) (tangentMapWithin I I' f s' q))) = tangentMapWithin I I' f s' q
[PROOFSTEP]
dsimp
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
this : f p.proj = (tangentMapWithin I I' f s p).proj
β’ β(LocalHomeomorph.symm (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)))
(β(chartAt (ModelProd H' E') (tangentMap I I' (β(chartAt H' (f p.proj)) β f) p))
(tangentMap I' I' (β(chartAt H' (f p.proj)))
(tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q))) =
tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q
[PROOFSTEP]
rw [this, tangentMap_chart]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
this : f p.proj = (tangentMapWithin I I' f s p).proj
β’ β(LocalHomeomorph.symm (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)))
(β(chartAt (ModelProd H' E') (tangentMap I I' (β(chartAt H' (tangentMapWithin I I' f s p).proj) β f) p))
(β(TotalSpace.toProd H' E').symm
(β(chartAt (ModelProd H' E') (tangentMapWithin I I' f s p))
(tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (tangentMapWithin I I' f s p).proj).toLocalEquiv.source β© s β©
(chartAt H p.proj).toLocalEquiv.source)
q)))) =
tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (tangentMapWithin I I' f s p).proj).toLocalEquiv.source β© s β©
(chartAt H p.proj).toLocalEquiv.source)
q
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
this : f p.proj = (tangentMapWithin I I' f s p).proj
β’ β(LocalHomeomorph.symm (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)))
(β(chartAt H' (f p.proj)) (f q.proj),
(β(chartAt (ModelProd H' E') (tangentMapWithin I I' f s p))
(tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source)
q)).snd) =
tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q
[PROOFSTEP]
have : tangentMapWithin I I' f s' q β (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)).source := by
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
this : f p.proj = (tangentMapWithin I I' f s p).proj
β’ tangentMapWithin I I' f s' q β (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)).toLocalEquiv.source
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
thisβ : f p.proj = (tangentMapWithin I I' f s p).proj
this : tangentMapWithin I I' f s' q β (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)).toLocalEquiv.source
β’ β(LocalHomeomorph.symm (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)))
(β(chartAt H' (f p.proj)) (f q.proj),
(β(chartAt (ModelProd H' E') (tangentMapWithin I I' f s p))
(tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source)
q)).snd) =
tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q
[PROOFSTEP]
exact (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)).left_inv this
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
Aβ :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
A :
tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q) =
tangentMap I' I' (βr) (tangentMapWithin I I' f s' q)
this : f p.proj = (tangentMapWithin I I' f s p).proj
β’ (tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (tangentMapWithin I I' f s p).proj).toLocalEquiv.source β© s β©
(chartAt H p.proj).toLocalEquiv.source)
q).proj β
(chartAt H' (tangentMapWithin I I' f s p).proj).toLocalEquiv.source
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
D :
β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
have E : tangentMapWithin I I' f s' q = tangentMapWithin I I' f s q :=
by
refine' tangentMapWithin_subset (by mfld_set_tac) U'q _
apply hf.mdifferentiableOn one_le_n
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
D :
β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
β’ tangentMapWithin I I' f s' q = tangentMapWithin I I' f s q
[PROOFSTEP]
refine' tangentMapWithin_subset (by mfld_set_tac) U'q _
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
D :
β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
β’ s' β s
[PROOFSTEP]
mfld_set_tac
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
D :
β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
β’ MDifferentiableWithinAt I I' f s q.proj
[PROOFSTEP]
apply hf.mdifferentiableOn one_le_n
[GOAL]
case a
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace E (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
D :
β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
β’ q.proj β s
[PROOFSTEP]
simp only [hq, mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
Eβ : Type u_2
instβΒ²Β³ : NormedAddCommGroup Eβ
instβΒ²Β² : NormedSpace π Eβ
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π Eβ H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H Eβ) := chartAt (ModelProd H Eβ) p
hDl : Dl = chartAt (ModelProd H Eβ) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H Eβ) := chartAt (ModelProd H Eβ) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace Eβ (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace Eβ (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace Eβ (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' ((βr β f) β β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) =
tangentMapWithin I I' (βr β f) s'
(tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)))
B : tangentMapWithin I I (β(LocalHomeomorph.symm l)) s'l (β(LocalHomeomorph.symm il) (βDl q)) = q
C : tangentMapWithin I I' (βr β f) s' q = tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q)
D :
β(LocalHomeomorph.symm Dr) (βir (tangentMapWithin I' I' (βr) r.source (tangentMapWithin I I' f s' q))) =
tangentMapWithin I I' f s' q
E : tangentMapWithin I I' f s' q = tangentMapWithin I I' f s q
β’ tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
[PROOFSTEP]
dsimp only [(Β· β Β·)] at A B C D E β’
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
Eβ : Type u_2
instβΒ²Β³ : NormedAddCommGroup Eβ
instβΒ²Β² : NormedSpace π Eβ
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π Eβ H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H Eβ) := chartAt (ModelProd H Eβ) p
hDl : Dl = chartAt (ModelProd H Eβ) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H Eβ) := chartAt (ModelProd H Eβ) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace Eβ (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace Eβ (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
q : TotalSpace Eβ (TangentSpace I)
hq :
(f q.proj β (chartAt H' (f p.proj)).toLocalEquiv.source β§ q.proj β s) β§
q.proj β (chartAt H p.proj).toLocalEquiv.source
U'q : UniqueMDiffWithinAt I s' q.proj
U'lq : UniqueMDiffWithinAt I s'l (βDl q).fst
A :
tangentMapWithin I I' (fun x => β(chartAt H' (f p.proj)) (f (β(LocalHomeomorph.symm (chartAt H p.proj)) x)))
((chartAt H p.proj).toLocalEquiv.target β©
β(LocalHomeomorph.symm (chartAt H p.proj)) β»ΒΉ'
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source))
(β(LocalHomeomorph.symm (chartAt (ModelProd H Eβ) (tangentMap I I (β(chartAt H p.proj)) p)))
(β(chartAt (ModelProd H Eβ) p) q)) =
tangentMapWithin I I' (fun x => β(chartAt H' (f p.proj)) (f x))
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source)
(tangentMapWithin I I (β(LocalHomeomorph.symm (chartAt H p.proj)))
((chartAt H p.proj).toLocalEquiv.target β©
β(LocalHomeomorph.symm (chartAt H p.proj)) β»ΒΉ'
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source))
(β(LocalHomeomorph.symm (chartAt (ModelProd H Eβ) (tangentMap I I (β(chartAt H p.proj)) p)))
(β(chartAt (ModelProd H Eβ) p) q)))
B :
tangentMapWithin I I (β(LocalHomeomorph.symm (chartAt H p.proj)))
((chartAt H p.proj).toLocalEquiv.target β©
β(LocalHomeomorph.symm (chartAt H p.proj)) β»ΒΉ'
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source))
(β(LocalHomeomorph.symm (chartAt (ModelProd H Eβ) (tangentMap I I (β(chartAt H p.proj)) p)))
(β(chartAt (ModelProd H Eβ) p) q)) =
q
C :
tangentMapWithin I I' (fun x => β(chartAt H' (f p.proj)) (f x))
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q =
tangentMapWithin I' I' (β(chartAt H' (f p.proj))) (chartAt H' (f p.proj)).toLocalEquiv.source
(tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q)
D :
β(LocalHomeomorph.symm (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)))
(β(chartAt (ModelProd H' E') (tangentMap I I' (fun x => β(chartAt H' (f p.proj)) (f x)) p))
(tangentMapWithin I' I' (β(chartAt H' (f p.proj))) (chartAt H' (f p.proj)).toLocalEquiv.source
(tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q))) =
tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q
E :
tangentMapWithin I I' f
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source) q =
tangentMapWithin I I' f s q
β’ tangentMapWithin I I' f s q =
β(LocalHomeomorph.symm (chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)))
(β(chartAt (ModelProd H' E') (tangentMap I I' (fun x => β(chartAt H' (f p.proj)) (f x)) p))
(tangentMapWithin I I' (fun x => β(chartAt H' (f p.proj)) (f (β(LocalHomeomorph.symm (chartAt H p.proj)) x)))
((chartAt H p.proj).toLocalEquiv.target β©
β(LocalHomeomorph.symm (chartAt H p.proj)) β»ΒΉ'
(f β»ΒΉ' (chartAt H' (f p.proj)).toLocalEquiv.source β© s β© (chartAt H p.proj).toLocalEquiv.source))
(β(LocalHomeomorph.symm (chartAt (ModelProd H Eβ) (tangentMap I I (β(chartAt H p.proj)) p)))
(β(chartAt (ModelProd H Eβ) p) q))))
[PROOFSTEP]
simp only [A, B, C, D, β E]
[GOAL]
case h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f s
hmn : m + 1 β€ n
hs : UniqueMDiffOn I s
one_le_n : 1 β€ n
p : TangentBundle I M
hf' :
ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(LocalEquiv.symm (extChartAt I x)))
((extChartAt I x).target β© β(LocalEquiv.symm (extChartAt I x)) β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
hp : p.proj β s
l : LocalHomeomorph M H := chartAt H p.proj
Dl : LocalHomeomorph (TangentBundle I M) (ModelProd H E) := chartAt (ModelProd H E) p
hDl : Dl = chartAt (ModelProd H E) p
r : LocalHomeomorph M' H' := chartAt H' (f p.proj)
Dr : LocalHomeomorph (TangentBundle I' M') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMapWithin I I' f s p)
il : LocalHomeomorph (TangentBundle I H) (ModelProd H E) := chartAt (ModelProd H E) (tangentMap I I (βl) p)
ir : LocalHomeomorph (TangentBundle I' H') (ModelProd H' E') := chartAt (ModelProd H' E') (tangentMap I I' (βr β f) p)
s' : Set M := f β»ΒΉ' r.source β© s β© l.source
s'_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'
s'l : Set H := l.target β© β(LocalHomeomorph.symm l) β»ΒΉ' s'
s'l_lift : Set (TotalSpace E (TangentSpace I)) := TotalSpace.proj β»ΒΉ' s'l
o : Set M
o_open : IsOpen o
ho : f β»ΒΉ' r.source β© s = o β© s
U' : UniqueMDiffOn I s'
U'l : UniqueMDiffOn I s'l
diff_f : ContMDiffOn I I' n f s'
diff_r : ContMDiffOn I' I' n (βr) r.source
diff_rf : ContMDiffOn I I' n (βr β f) s'
diff_l : ContMDiffOn I I n (β(LocalHomeomorph.symm l)) s'l
diff_rfl : ContMDiffOn I I' n (βr β f β β(LocalHomeomorph.symm l)) s'l
diff_rfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_irrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_Drirrfl_lift :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) s'l_lift
diff_DrirrflilDl :
ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m
(β(LocalHomeomorph.symm Dr) β
(βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l) β β(LocalHomeomorph.symm il) β βDl)
s'_lift
eq_comp :
β (q : TotalSpace E (TangentSpace I)),
q β s'_lift β
tangentMapWithin I I' f s q =
(β(LocalHomeomorph.symm Dr) β
βir β tangentMapWithin I I' (βr β f β β(LocalHomeomorph.symm l)) s'l β β(LocalHomeomorph.symm il) β βDl)
q
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMapWithin I I' f s) s'_lift
[PROOFSTEP]
exact diff_DrirrflilDl.congr eq_comp
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiff I I' n f
hmn : m + 1 β€ n
β’ ContMDiff (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMap I I' f)
[PROOFSTEP]
rw [β contMDiffOn_univ] at hf β’
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f univ
hmn : m + 1 β€ n
β’ ContMDiffOn (ModelWithCorners.tangent I) (ModelWithCorners.tangent I') m (tangentMap I I' f) univ
[PROOFSTEP]
convert hf.contMDiffOn_tangentMapWithin hmn uniqueMDiffOn_univ
[GOAL]
case h.e'_22
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f univ
hmn : m + 1 β€ n
β’ tangentMap I I' f = tangentMapWithin I I' f univ
[PROOFSTEP]
rw [tangentMapWithin_univ]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiff I I' n f
hmn : 1 β€ n
β’ Continuous (tangentMap I I' f)
[PROOFSTEP]
rw [β contMDiffOn_univ] at hf
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f univ
hmn : 1 β€ n
β’ Continuous (tangentMap I I' f)
[PROOFSTEP]
rw [continuous_iff_continuousOn_univ]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f univ
hmn : 1 β€ n
β’ ContinuousOn (tangentMap I I' f) univ
[PROOFSTEP]
convert hf.continuousOn_tangentMapWithin hmn uniqueMDiffOn_univ
[GOAL]
case h.e'_5
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
hf : ContMDiffOn I I' n f univ
hmn : 1 β€ n
β’ tangentMap I I' f = tangentMapWithin I I' f univ
[PROOFSTEP]
rw [tangentMapWithin_univ]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
x : M
m n : ββ
p : TangentBundle I M
β’ tangentMap I (ModelWithCorners.tangent I) (zeroSection E (TangentSpace I)) p =
{ proj := { proj := p.proj, snd := 0 }, snd := (p.snd, 0) }
[PROOFSTEP]
rcases p with β¨x, vβ©
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
β’ tangentMap I (ModelWithCorners.tangent I) (zeroSection E (TangentSpace I)) { proj := x, snd := v } =
{ proj := { proj := { proj := x, snd := v }.proj, snd := 0 }, snd := ({ proj := x, snd := v }.snd, 0) }
[PROOFSTEP]
have N : I.symm β»ΒΉ' (chartAt H x).target β π (I ((chartAt H x) x)) :=
by
apply IsOpen.mem_nhds
apply (LocalHomeomorph.open_target _).preimage I.continuous_invFun
simp only [mfld_simps]
[GOAL]
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
β’ β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
[PROOFSTEP]
apply IsOpen.mem_nhds
[GOAL]
case hs
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
β’ IsOpen (β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
case ha
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
β’ βI (β(chartAt H x) x) β β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target
[PROOFSTEP]
apply (LocalHomeomorph.open_target _).preimage I.continuous_invFun
[GOAL]
case ha
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
N : Type u_10
instβΒΉβ° : TopologicalSpace N
instββΉ : ChartedSpace G N
Js : SmoothManifoldWithCorners J N
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
β’ βI (β(chartAt H x) x) β β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target
[PROOFSTEP]
simp only [mfld_simps]
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
β’ tangentMap I (ModelWithCorners.tangent I) (zeroSection E (TangentSpace I)) { proj := x, snd := v } =
{ proj := { proj := { proj := x, snd := v }.proj, snd := 0 }, snd := ({ proj := x, snd := v }.snd, 0) }
[PROOFSTEP]
have A : MDifferentiableAt I I.tangent (fun x => @TotalSpace.mk M E (TangentSpace I) x 0) x :=
haveI : Smooth I (I.prod π(π, E)) (zeroSection E (TangentSpace I : M β Type _)) :=
Bundle.smooth_zeroSection π (TangentSpace I : M β Type _)
this.mdifferentiableAt
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
β’ tangentMap I (ModelWithCorners.tangent I) (zeroSection E (TangentSpace I)) { proj := x, snd := v } =
{ proj := { proj := { proj := x, snd := v }.proj, snd := 0 }, snd := ({ proj := x, snd := v }.snd, 0) }
[PROOFSTEP]
have B : fderivWithin π (fun x' : E => (x', (0 : E))) (Set.range I) (I ((chartAt H x) x)) v = (v, 0)
[GOAL]
case B
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
β’ β(fderivWithin π (fun x' => (x', 0)) (range βI) (βI (β(chartAt H x) x))) v = (v, 0)
[PROOFSTEP]
rw [fderivWithin_eq_fderiv, DifferentiableAt.fderiv_prod]
[GOAL]
case B
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
β’ β(ContinuousLinearMap.prod (fderiv π (fun x' => x') (βI (β(chartAt H x) x)))
(fderiv π (fun x' => 0) (βI (β(chartAt H x) x))))
v =
(v, 0)
[PROOFSTEP]
simp
[GOAL]
case B.hfβ
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
β’ DifferentiableAt π (fun x' => x') (βI (β(chartAt H x) x))
[PROOFSTEP]
exact differentiableAt_id'
[GOAL]
case B.hfβ
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
β’ DifferentiableAt π (fun x' => 0) (βI (β(chartAt H x) x))
[PROOFSTEP]
exact differentiableAt_const _
[GOAL]
case B.hs
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
β’ UniqueDiffWithinAt π (range βI) (βI (β(chartAt H x) x))
[PROOFSTEP]
exact ModelWithCorners.unique_diff_at_image I
[GOAL]
case B.h
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
β’ DifferentiableAt π (fun x' => (x', 0)) (βI (β(chartAt H x) x))
[PROOFSTEP]
exact differentiableAt_id'.prod (differentiableAt_const _)
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
B : β(fderivWithin π (fun x' => (x', 0)) (range βI) (βI (β(chartAt H x) x))) v = (v, 0)
β’ tangentMap I (ModelWithCorners.tangent I) (zeroSection E (TangentSpace I)) { proj := x, snd := v } =
{ proj := { proj := { proj := x, snd := v }.proj, snd := 0 }, snd := ({ proj := x, snd := v }.snd, 0) }
[PROOFSTEP]
simp only [Bundle.zeroSection, tangentMap, mfderiv, A, if_pos, chartAt, FiberBundle.chartedSpace_chartAt,
TangentBundle.trivializationAt_apply, tangentBundleCore, Function.comp, ContinuousLinearMap.map_zero, mfld_simps]
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
B : β(fderivWithin π (fun x' => (x', 0)) (range βI) (βI (β(chartAt H x) x))) v = (v, 0)
β’ β(fderivWithin π
(fun x_1 =>
(βI
(β(ChartedSpace.chartAt x)
(β(LocalHomeomorph.symm (ChartedSpace.chartAt x)) (β(ModelWithCorners.symm I) x_1))),
0))
(range βI) (βI (β(ChartedSpace.chartAt x) x)))
v =
(v, 0)
[PROOFSTEP]
rw [β fderivWithin_inter N] at B
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
B :
β(fderivWithin π (fun x' => (x', 0)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
(βI (β(chartAt H x) x)))
v =
(v, 0)
β’ β(fderivWithin π
(fun x_1 =>
(βI
(β(ChartedSpace.chartAt x)
(β(LocalHomeomorph.symm (ChartedSpace.chartAt x)) (β(ModelWithCorners.symm I) x_1))),
0))
(range βI) (βI (β(ChartedSpace.chartAt x) x)))
v =
(v, 0)
[PROOFSTEP]
rw [β fderivWithin_inter N, β B]
[GOAL]
case mk
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
B :
β(fderivWithin π (fun x' => (x', 0)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
(βI (β(chartAt H x) x)))
v =
(v, 0)
β’ β(fderivWithin π
(fun x_1 =>
(βI
(β(ChartedSpace.chartAt x)
(β(LocalHomeomorph.symm (ChartedSpace.chartAt x)) (β(ModelWithCorners.symm I) x_1))),
0))
(range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target) (βI (β(chartAt H x) x)))
v =
β(fderivWithin π (fun x' => (x', 0)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
(βI (β(chartAt H x) x)))
v
[PROOFSTEP]
congr 1
[GOAL]
case mk.e_a
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
B :
β(fderivWithin π (fun x' => (x', 0)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
(βI (β(chartAt H x) x)))
v =
(v, 0)
β’ fderivWithin π
(fun x_1 =>
(βI
(β(ChartedSpace.chartAt x)
(β(LocalHomeomorph.symm (ChartedSpace.chartAt x)) (β(ModelWithCorners.symm I) x_1))),
0))
(range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target) (βI (β(chartAt H x) x)) =
fderivWithin π (fun x' => (x', 0)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
(βI (β(chartAt H x) x))
[PROOFSTEP]
refine' fderivWithin_congr (fun y hy => _) _
[GOAL]
case mk.e_a.refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
B :
β(fderivWithin π (fun x' => (x', 0)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
(βI (β(chartAt H x) x)))
v =
(v, 0)
y : E
hy : y β range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target
β’ (βI (β(ChartedSpace.chartAt x) (β(LocalHomeomorph.symm (ChartedSpace.chartAt x)) (β(ModelWithCorners.symm I) y))),
0) =
(y, 0)
[PROOFSTEP]
simp only [mfld_simps] at hy
[GOAL]
case mk.e_a.refine'_1
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
B :
β(fderivWithin π (fun x' => (x', 0)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
(βI (β(chartAt H x) x)))
v =
(v, 0)
y : E
hy : y β range βI β§ β(ModelWithCorners.symm I) y β (chartAt H x).toLocalEquiv.target
β’ (βI (β(ChartedSpace.chartAt x) (β(LocalHomeomorph.symm (ChartedSpace.chartAt x)) (β(ModelWithCorners.symm I) y))),
0) =
(y, 0)
[PROOFSTEP]
simp only [hy, Prod.mk.inj_iff, mfld_simps]
[GOAL]
case mk.e_a.refine'_2
π : Type u_1
instβΒ²β΄ : NontriviallyNormedField π
E : Type u_2
instβΒ²Β³ : NormedAddCommGroup E
instβΒ²Β² : NormedSpace π E
H : Type u_3
instβΒ²ΒΉ : TopologicalSpace H
I : ModelWithCorners π E H
M : Type u_4
instβΒ²β° : TopologicalSpace M
instβΒΉβΉ : ChartedSpace H M
Is : SmoothManifoldWithCorners I M
E' : Type u_5
instβΒΉβΈ : NormedAddCommGroup E'
instβΒΉβ· : NormedSpace π E'
H' : Type u_6
instβΒΉβΆ : TopologicalSpace H'
I' : ModelWithCorners π E' H'
M' : Type u_7
instβΒΉβ΅ : TopologicalSpace M'
instβΒΉβ΄ : ChartedSpace H' M'
I's : SmoothManifoldWithCorners I' M'
F : Type u_8
instβΒΉΒ³ : NormedAddCommGroup F
instβΒΉΒ² : NormedSpace π F
G : Type u_9
instβΒΉΒΉ : TopologicalSpace G
J : ModelWithCorners π F G
Nβ : Type u_10
instβΒΉβ° : TopologicalSpace Nβ
instββΉ : ChartedSpace G Nβ
Js : SmoothManifoldWithCorners J Nβ
F' : Type u_11
instββΈ : NormedAddCommGroup F'
instββ· : NormedSpace π F'
G' : Type u_12
instββΆ : TopologicalSpace G'
J' : ModelWithCorners π F' G'
N' : Type u_13
instββ΅ : TopologicalSpace N'
instββ΄ : ChartedSpace G' N'
J's : SmoothManifoldWithCorners J' N'
Fβ : Type u_14
instβΒ³ : NormedAddCommGroup Fβ
instβΒ² : NormedSpace π Fβ
Fβ : Type u_15
instβΒΉ : NormedAddCommGroup Fβ
instβ : NormedSpace π Fβ
f fβ : M β M'
s sβ t : Set M
xβ : M
m n : ββ
x : M
v : TangentSpace I x
N : β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target β π (βI (β(chartAt H x) x))
A : MDifferentiableAt I (ModelWithCorners.tangent I) (fun x => { proj := x, snd := 0 }) x
B :
β(fderivWithin π (fun x' => (x', 0)) (range βI β© β(ModelWithCorners.symm I) β»ΒΉ' (chartAt H x).toLocalEquiv.target)
(βI (β(chartAt H x) x)))
v =
(v, 0)
β’ (βI
(β(ChartedSpace.chartAt x)
(β(LocalHomeomorph.symm (ChartedSpace.chartAt x)) (β(ModelWithCorners.symm I) (βI (β(chartAt H x) x))))),
0) =
(βI (β(chartAt H x) x), 0)
[PROOFSTEP]
simp only [Prod.mk.inj_iff, mfld_simps]
|
# Introduction to Partial Differential Equations
## (PDEs)
-----
Questions:
- Which physical systems can be described using a PDE?
- What is the Laplacian operator?
- When to I need boundary conditions and initial conditions?
------
------
Objectives:
- Recognise common classes of PDE: the diffusion equation, Poisson's equation and the wave equation
- Express the Laplacian as a differential operator
- Identify boundary value problems and initial value problems
-----
- In the previous section of the course we studied <bold>ordinary differential equations</bold>. ODEs have a single input (also known as independent variable) - for example, time.
- Partial differential equations (PDEs) have multiple inputs (independent variables). For example, think about a sheet of metal that has been heated unevenly across the surface. Over time, heat will diffuse through the 2-dimensional sheet. The temperature depends on both time *and* position - there are two inputs.
- Because PDEs have multiple inputs they are generally much more difficult to solve analytically than ODEs. However, there are a range of numerical methods that can be used to find approximate solutions.
### PDEs have application across a wide variety of topics
The same type of PDE often appears in different contexts. For example, the <mark>diffusion equation</mark> takes the form:
\begin{equation}
\nabla^2T = \alpha \frac{\partial T}{\partial t}
\end{equation}
When used to describe heat diffusion, this PDE is known as the heat equation. This same PDE however can be used to model other seemingly unrelated processes such as brownian motion, or used in financial modelling via the Black-Sholes equation.
Another type of PDE is known as <mark>Poisson's equation</mark>:
\begin{equation}
\nabla^2\phi = f(x,y,z)
\end{equation}
Poisson's equation can be used to describe electrostatic forces, where $\phi$ is the electric potential. It can also be applied to mechanics (where $\phi$ is the gravitational potential) or thermodynamics (where $\phi$ is the temperature). When $f(x,y,z)=0$ this equation is known as Laplace's equation.
The third common type of PDE is the <mark>wave equation</mark>:
\begin{equation}
\nabla^2r = \alpha \frac{\partial^2 r}{\partial t^2}
\end{equation}
This describes mechanical processes such as the vibration of a string or the motion of a pendulum. It can also be used in electrodynamics to describe the exchange of energy between the electric and magnetic fields.
In this course we will look at techniques for solving the diffusion equation and Poisson's equation, but many of the topics we will discuss - such as boundary conditions, and finite difference methods - can be transferred to PDEs more generally.
### The Laplacian operator corresponds to an average rate of change
*But what is the operator $\nabla^2$?*. This is the <mark>Laplacian operator</mark>. When applied to $\phi$ and written in full for a three dimensional cartesian coordinate system with dependent variables $x$, $y$ and $z$ it takes the following form:
\begin{equation}
\nabla^2\phi = \frac{\partial^2\phi}{\partial x^2} + \frac{\partial^2\phi}{\partial y^2} + \frac{\partial^2\phi}{\partial z^2}.
\end{equation}
We can think of the laplacian as encoding an average rate of change - the difference between a value at a point and the average of the values around that point.
```python
# https://gist.github.com/dm-wyncode/55823165c104717ca49863fc526d1354
"""Embed a YouTube video via its embed url into a notebook."""
from functools import partial
from IPython.display import display, IFrame
width, height = (560, 315, )
def _iframe_attrs(embed_url):
"""Get IFrame args."""
return (
('src', 'width', 'height'),
(embed_url, width, height, ),
)
def _get_args(embed_url):
"""Get args for type to create a class."""
iframe = dict(zip(*_iframe_attrs(embed_url)))
attrs = {
'display': partial(display, IFrame(**iframe)),
}
return ('YouTubeVideo', (object, ), attrs, )
def youtube_video(embed_url):
"""Embed YouTube video into a notebook.
Place this module into the same directory as the notebook.
>>> from embed import youtube_video
>>> youtube_video(url).display()
"""
YouTubeVideo = type(*_get_args(embed_url)) # make a class
return YouTubeVideo() # return an object
```
```python
youtube_video("https://youtu.be/EW08rD-GFh0").display()
```
### Boundary value problems
<mark>Boundary value problems</mark> describe the behaviour of a variable in a space and we are given some constraints on the variable around the boundary of that space. For example, consider the 2-dimensional problem of a thin rectangular sheet with one side at voltage $V$ and all others at voltage zero.
The specification that one side is at voltage $V$ and all others are at voltage zero are the <mark>boundary conditions</mark>. We could then calculate the electrostatic potential $\phi$ at all points within the sheet using the two-dimensional Laplace's equation:
\begin{equation}
\nabla^2\phi = \frac{\partial^2\phi}{\partial x^2} + \frac{\partial^2\phi}{\partial y^2} = 0
\end{equation}
#### Initial value problems
<mark>Initial value problems</mark> are where the field - or other variable of interest - is varying in both space and time. We now require boundary conditions *and* initial values. This is a more difficult type of PDE to solve.
For example, consider heat diffusion in a two-dimensional sheet. Here we could specify that there is no heat flow in or out of the sheet - this is the boundary condition.
We could also specify that at time $t=0$ the centre of the sheet is at temperature $T_1$, whilst surrounding areas are at temperature $T_0$. This is the initial condition. It differs from a boundary condition in that we are told what the temperature is at the start of our time grid (at $t=0$) but not at the end of our time grid (when the simulation finishes).
We could then calculate the temperature at time $t$ at all points $[x,y]$ within the sheet using the two-dimensional Diffusion equation:
\begin{equation}
\nabla^2T = \frac{\partial^2 T}{\partial x^2} + \frac{\partial^2 T}{\partial y^2}=\alpha \frac{\partial T}{\partial t}
\end{equation}
# Laplace's equation for electrostatics
-----
Questions:
- How do I use a finite difference method to calculate derivatives?
- How do I use the relaxation method to solve Laplace's equation?
------
### The method of finite differences
Consider the two-dimensional Laplace equation for the electric potential $\phi$ subject to appropriate boundary conditions:
\begin{equation}
\frac{\partial^2\phi}{\partial x^2} + \frac{\partial^2\phi}{\partial y^2} = 0
\end{equation}
The method of finite differences involves dividing the space into a grid of discrete points $[x,y]$ and calculating numerical derivatives or at each of these points.
But how do we calculate these numerical derivatives?
Real physical problems are in three dimensions, but we can more easily visualise the method of finite differences - and the extension to three dimensions is straight forward.
### Calculating numerical derivatives
The standard definition of a derivative is
\begin{equation}
\frac{\mathrm{d} f}{\mathrm{d} x} = \lim_{h\to0}\frac{f(x+h)-f(x)}{h}.
\end{equation}
To calculate the derivative numerically we make $h$ very small and calculate
\begin{equation}
\frac{\mathrm{d} f}{\mathrm{d} x} \simeq \frac{f(x+h)-f(x)}{h}.
\end{equation}
This is the <mark>forward difference</mark> because it is measured in the forward direction from $x$.
The <mark>backward difference</mark> is measured in the backward direction from $x$:
\begin{equation}
\frac{\mathrm{d} f}{\mathrm{d} x} \simeq \frac{f(x)-f(x-h)}{h},
\end{equation}
and the <mark>central difference</mark> uses both the forwards and backwards directions around $x$:
\begin{equation}
\frac{\mathrm{d} f}{\mathrm{d} x} \simeq \frac{f(x+\frac{h}{h2})-f(x-\frac{h}{2})}{h},
\end{equation}
### Numerical second-order derivatives
The second derivative is a derivative of a derivative, and so we can calculate it be applying the first derivative formulas twice. The resulting expression (after application of central differences) is:
\begin{equation}
\frac{\mathrm{d} ^2f}{\mathrm{d} x^2} \simeq \frac{f(x+h)-2f(x)+f(x-h)}{h^2}.
\end{equation}
### Numerical partial derivatives
The extension to partial derivatives is straight-forward:
\begin{equation}
\frac{\mathrm{d} f}{\mathrm{d} x} \simeq \frac{f(x+\frac{h}{h2})-f(x-\frac{h}{2})}{h},
\end{equation}
\begin{equation}
\frac{\partial f}{\partial x} \simeq \frac{f(x+\frac{h}{2},y)-f(x-\frac{h}{2},y)}{h},
\end{equation}
\begin{equation}
\frac{\partial f}{\partial y} \simeq \frac{f(x,y+\frac{h}{2})-f(x,y-\frac{h}{2})}{h},
\end{equation}
\begin{equation}
\frac{\mathrm{d} ^2f}{\mathrm{d} x^2} \simeq \frac{f(x+h)-2f(x)+f(x-h)}{h^2}.
\end{equation}
\begin{equation}
\frac{\partial ^2f}{\partial x^2} \simeq \frac{f(x+h,y)-2f(x,y)+f(x-h,y)}{h^2},
\end{equation}
\begin{equation}
\frac{\partial ^2f}{\partial y^2} \simeq \frac{f(x,y+h)-2f(x,y)+f(x,y-h)}{h^2}.
\end{equation}
By adding the two equations above, <mark>the Laplacian</mark> in two dimensions is:
\begin{equation}
\frac{\partial ^2f}{\partial x^2} + \frac{\partial ^2f}{\partial y^2} \simeq \frac{f(x+h,y)+f(x-h,y)+f(x,y+h)+f(x,y-h)-4f(x,y)}{h^2},
\end{equation}
### PDEs --> linear simulatenous equations
Returning to our Laplace equation for for the electric potential $\phi$:
\begin{equation}
\frac{\partial^2\phi}{\partial x^2} + \frac{\partial^2\phi}{\partial y^2} = 0
\end{equation}
The numerical Laplacian can be substituted into the equation above, giving us a set of $n$ simulatenous equations for the $n$ grid points.
\begin{equation}
\frac{\phi(x+h,y)+\phi(x-h,y)+\phi(x,y+h)+\phi(x,y-h)-4\phi(x,y)}{a^2} = 0,
\end{equation}
where $a$ is the distance between each grid point.
### To solve we use the relaxation method
\begin{equation}
\frac{\phi(x+h,y)+\phi(x-h,y)+\phi(x,y+h)+\phi(x,y-h)-4\phi(x,y)}{a^2} = 0,
\end{equation}
\begin{equation}
\phi(x,y)=\frac{1}{4}\left(\phi(x+h,y)+\phi(x-h,y)+\phi(x,y+h)+\phi(x,y-h)\right).
\end{equation}
This tells us that $\phi(x,y)$ is the average of the surrounding grid points, which can be represented visually as:
### To solve we use the relaxation method
#### Step one
Fix $\phi(x,y)$ at the boundaries using the boundary conditions.
#### Step two
Guess the initial values of the interior $\phi(x,y)$ points - our guesses do not need to be good, and can be zero.
#### Step three
Calculate new values of $\phi'(x,y)$ at all points in space using an iterative method:
\begin{equation}
\phi'(x,y)=\frac{1}{4}\left(\phi(x+h,y)+\phi(x-h,y)+\phi(x,y+h)+\phi(x,y-h)\right).
\end{equation}
#### Step four
Repeat until the $\phi(x,y)$ values converge*, and that is our solution.
*Convergence can be tested by specifying what the maximum difference should be between iterations. For example, that $\phi'(x,y)-\phi(x,y)< 1e-5$ for all grid points.
# Heat Diffusion
----
Questions:
- How do I use the Forward-Time Centred-Space method (FTCS) to solve the diffusion equation?
---
### The diffusion equation is an initial value problem
An initial value problem is more complex than a boundary value problem as we are told the starting conditions and then have to predict future behaviour as a function of time.
#### Example
A 10cm rod of stainless steel initially at a uniform temperature of 20$^\mathrm{o}$ Celsius. The rod is dipped in a hot water bath at 90$^\mathrm{o}$ Celsius at one end, and held in someone's hand at the other. Assume that the hand is at constant body temperature throughout (27$^\mathrm{o}$ Celsius).
Assume:
- that the rod is perfectly insulated so that heat only moves horizontally --> a 1D problem
- neither the hot water bath or the hand change temperature
Thermal conduction is described by the diffusion equation:
\begin{equation}
\frac{\partial \phi}{\partial t} = D\frac{\partial^2 \phi}{\partial x^2},
\end{equation}
where $D$ is the material dependent thermal diffusivity. For steel $D=4.25\times10^{-6}\mathrm{m}^2\mathrm{s}^{-1}$.
### Why can't we use the relaxation method?
We solved Laplace's equation and that had three variables ($x$,$y$,$z$) - why not do the same thing here?
The problem is that we only have an *initial* condition in the time dimension - we know the value of $\phi(x,t)$ at $t=0$ but we do not typically know the value of $t$ at a later point. In the spatial dimensions we know the boundary conditions at either end of the grid.
Instead, we will use the <mark>Forward-Time Centred-Space method (FTCS)</mark>.
### There are two steps to the Forward-Time Centred-Space method
#### Step one
Use the finite difference method to express the 1D Laplacian as a set of simulatenous equations:
\begin{equation}
\frac{\partial^2\phi}{\partial x^2} = \frac{\phi(x+a,t)+\phi(x-a,t) - 2\phi(x,t)}{a^2}
\end{equation}
where $a$ is the grid spacing.
Substitute this back into the diffusion equation:
\begin{equation}
\frac{d \phi}{d t} = \frac{D}{a^2}(\phi(x+a,t)+\phi(x-a,t)-2\phi(x,t))
\end{equation}
<mark>We now have a set of simultaneous ODEs for $\phi(x,t)$. </mark>
#### Step two
So we can use Euler's method to evolve the system forward in time. Euler's method for solving an ODE of the form $\frac{d\phi}{dt} = f(\phi,t)$ has the general form:
\begin{equation}
\phi(t+h) \simeq \phi(t) + hf(\phi, t).
\end{equation}
Applying this to Equation 3 gives:
\begin{equation}
\phi(x,t+h) = \phi(x,t) + h\frac{D}{a^2}(\phi(x+a,t)+\phi(x-a,t)-2\phi(x,t))
\end{equation}
# Evaluating numerical errors and accuracy
-----
Questions:
- Which numerical errors are unavoidable in a Python programme?
- How do I choose the optimum step size $h$ when using the finite difference method?
- What do the terms first-order accurate and second-order accurate mean?
- How can I measure the speed of my code?
-----
### Finite difference methods have two sources of error
- There are two sources of errors for finite difference methods:
- the approximation that the step size $h$ is small but not zero.
- the numerical rounding errors for floating point numbers
- If we decrease the step size $h$:
- the finite-difference approximation will improve
- the runtime of the programme will increase
- counter-intuitively, the rounding error might *increase*.
- So it is possible that by decreasing $h$ we make our programme *less* accurate *and* it takes longer to run!
To demonstrate this, consider the Taylor expansion of $f(x)$ about $x$:
\begin{equation}
f(x+h) = f(x) + hf'(x) +\frac{1}{2}h^2f''(x) + \ldots
\end{equation}
Re-arrange the expression to get the expression for the forward difference method:
\begin{equation}
f'(x) = \frac{f(x+h)}{h} - \frac{1}{2}hf''(x)+\ldots
\end{equation}
A computer can typically store a number $f(x)$ to an accuracy of 16 significant figures, or $Cf(x)$ where $C=10^{-16}$. In the worst case, this makes the error $\epsilon$ on our derivative:
\begin{equation}
\epsilon = \frac{2C|f(x)|}{h} + \frac{1}{2}h|f''(x)|.
\end{equation}
We want to find the value of $h$ which minimises this error so we differentiate with respect to $h$ and set the result equal to zero.
\begin{equation}
-\frac{2C|f(x)|}{h^2} + h|f''(x)| = 0
\end{equation}
\begin{equation}
h = \sqrt{4C\lvert\frac{f(x)}{f''(x)}\rvert}
\end{equation}
If $f(x)$ and $f''(x)$ are order 1, then $h$ should be order $\sqrt{C}$, or $10^{-8}$.
Similar reasoning applied to the central difference formula suggests that the optimum step size for this method is $10^{-5}$.
|
function X = tendiag(v,sz)
%TENDIAG Creates a tensor with v on the diagonal.
%
% TENDIAG(V) creates a tensor with N dimensions, each of size N, where N
% is the number of elements of V. The elements of V are placed on the
% superdiagonal.
%
% TENDIAG(V,SZ) is the same as above but creates a tensor of size SZ. If
% SZ is not big enough, the tensor will be enlarged to accommodate the
% elements of V on the superdiagonal.
%
% Examples
% X = tendiag([0.1 0.22 0.333]) %<-- creates a 3x3x3 tensor
%
% See also TENSOR, SPTENDIAG.
%
%MATLAB Tensor Toolbox.
%Copyright 2012, Sandia Corporation.
% This is the MATLAB Tensor Toolbox by T. Kolda, B. Bader, and others.
% http://www.sandia.gov/~tgkolda/TensorToolbox.
% Copyright (2012) Sandia Corporation. Under the terms of Contract
% DE-AC04-94AL85000, there is a non-exclusive license for use of this
% work by or on behalf of the U.S. Government. Export of this data may
% require a license from the United States Government.
% The full license terms can be found in the file LICENSE.txt
% Make sure v is a column vector
v = reshape(v,[numel(v) 1]);
N = numel(v);
if ~exist('sz','var')
sz = repmat(N,1,N);
end
X = tenzeros(sz);
subs = repmat((1:N)', 1, length(sz));
X(subs) = v;
|
The Thame Curved Electric Bathroom Heated Towel Rail Radiator is the ideal bathroom heating solution for those who need full control over the warmth in their homes. Made of high-quality stainless steel, this towel rail radiator features highly conductive materials, is corrosion resistant and will last for years.
Cost effective and environment friendly, this CE approved radiator is the ultimate electric powered bathroom heating solution, plus it will blend in anywhere offering a touch of class. Its long life is guaranteed with a 2 years manufacturer's guarantee. |
FΓΌr $q \neq 1$ kann die n-te Partialsumme der geometrischen Reihe wie folgt berechnet werden:
$$
\sum_{k=0}^{n}{q^{k}} = \frac{1-q^{n+1}}{1-q}
$$
Zeigen Sie dies empirisch, indem Sie mithilfe von `sympy` die linke und rechte Seite in einer for-Schleife fΓΌr $n = 1, \ldots, 5$ berechnen und deren faktorisierte Formen mit einem logischen Operator vergleichen. Geben Sie dies fΓΌr jedes $n$ aus. AnschlieΓend berechnen Sie die 5-te Partialsumme an der Stelle $q = 3$ (indem Sie mittels einer `sympy` Routine fΓΌr $q$ den konkreten Wert ΓΌbergeben) und geben diese aus.
```python
from sympy.abc import k, n, q
from sympy import Sum
for ni in range(1, 6):
geom_series = Sum(q**k, (k, 0, ni))
geom_formula = (1 - q**(ni + 1))/(1 - q)
print(f'n = {ni}, Same factorized form: {geom_series.doit().factor() == geom_formula.factor()}')
```
n = 1, Same factorized form: True
n = 2, Same factorized form: True
n = 3, Same factorized form: True
n = 4, Same factorized form: True
n = 5, Same factorized form: True
```python
geom_series = Sum(q**k, (k, 0, n))
geom_formula = (1 - q**(n + 1))/(1 - q)
subs_dict = {k: v for k, v in zip('nq', [5, 3])}
for function, label in zip(
[geom_series, geom_formula],
['Series', 'Formula']
):
print(f'{label}: {function.evalf(subs = subs_dict)}, n = 5, q = 3')
```
Series: 364.000000000000, n = 5, q = 3
Formula: 364.000000000000, n = 5, q = 3
|
If $f$ is holomorphic on an open set $s$ and $f(z) = g(z)(z - z_0)$ for all $z \in s$, then $z_0$ is a simple zero of $f$. |
Require Import Kami.AllNotations.
Require Import StdLibKami.Fifo.Ifc.
Require Import StdLibKami.GenericFifo.Ifc.
Section Spec.
Context {ifcParams : Fifo.Ifc.Params}.
Class Params := {fifo : @Fifo.Ifc.Ifc ifcParams;
genericFifo : @GenericFifo.Ifc.Ifc (GenericFifo.Ifc.Build_Params
(@Fifo.Ifc.name ifcParams)
(@Fifo.Ifc.k ifcParams)
(@Fifo.Ifc.size ifcParams))}.
(* Class Params := {genericParams : @GenericFifo.Ifc.Ifc (GenericFifo.Ifc.Build_Params *)
(* (@Fifo.Ifc.name ifcParams) *)
(* (@Fifo.Ifc.k ifcParams) *)
(* (@Fifo.Ifc.size ifcParams))}. *)
Context {params : Params}.
Local Notation genericParams := (GenericFifo.Ifc.Build_Params
(@Fifo.Ifc.name ifcParams)
(@Fifo.Ifc.k ifcParams)
(@Fifo.Ifc.size ifcParams)).
Local Open Scope kami_expr.
Local Open Scope kami_action.
Local Definition propagate ty: ActionT ty Void :=
Retv.
Local Definition isEmpty ty: ActionT ty Bool :=
(@Fifo.Ifc.isEmpty ifcParams fifo ty).
Local Definition isFull ty: ActionT ty Bool :=
(@Fifo.Ifc.isFull ifcParams fifo ty).
Local Definition numFree ty: ActionT ty (Bit ((@lgSize genericParams) + 1)) :=
(@Fifo.Ifc.numFree ifcParams fifo ty).
Local Definition first ty: ActionT ty (Maybe (@k genericParams)) :=
(@Fifo.Ifc.first ifcParams fifo ty).
Local Definition deq ty: ActionT ty (Maybe (@k genericParams)) :=
(@Fifo.Ifc.deq ifcParams fifo ty).
Local Definition enq ty (new: ty (@k genericParams)): ActionT ty Bool :=
(@Fifo.Ifc.enq ifcParams fifo ty new).
Local Definition flush ty: ActionT ty Void :=
(@Fifo.Ifc.flush ifcParams fifo ty).
Local Definition regs : list RegInitT := (@Fifo.Ifc.regs ifcParams fifo).
Definition Extension: Ifc :=
{|
Ifc.propagate := propagate;
Ifc.regs := regs;
Ifc.regFiles := nil;
Ifc.isEmpty := isEmpty;
Ifc.isFull := isFull;
Ifc.numFree := numFree;
Ifc.first := first;
Ifc.deq := deq;
Ifc.enq := enq;
Ifc.flush := flush
|}.
End Spec.
|
-- Andreas, 2017-12-01, issue #2859 introduced by parameter-refinement
-- In Agda 2.5.2 any definition by pattern matching in a module
-- with a parameter that shadows a constructor will complain
-- about pattern variables with the same name as a constructor.
-- These are pattern variables added by the parameter-refinement
-- machinery, not user written ones. Thus, no reason to complain here.
-- {-# OPTIONS -v scope.pat:60 #-}
-- {-# OPTIONS -v tc.lhs.shadow:30 #-}
data D : Set where
c : D
module M (c : D) where
data DD : Set where
cc : DD
should-work : DD β Set
should-work cc = DD
should-fail : D β D
should-fail c = c
-- Expected error:
-- The pattern variable c has the same name as the constructor c
-- when checking the clause test c = c
|
[STATEMENT]
lemma icomp_fcomp: "\<theta> \<circ>\<^sub>s i = fsub_to_isub (isub_to_fsub \<theta> \<cdot> isub_to_fsub i)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<theta> \<circ>\<^sub>s i = (\<lambda>x. fterm_to_iterm (((\<lambda>x. iterm_to_fterm (\<theta> x)) \<cdot> (\<lambda>x. iterm_to_fterm (i x))) x))
[PROOF STEP]
unfolding composition_def subst_compose_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (\<lambda>x. \<theta> x \<cdot> i) = (\<lambda>x. fterm_to_iterm (iterm_to_fterm (\<theta> x) \<cdot>\<^sub>t (\<lambda>x. iterm_to_fterm (i x))))
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. \<And>x. \<theta> x \<cdot> i = fterm_to_iterm (iterm_to_fterm (\<theta> x) \<cdot>\<^sub>t (\<lambda>x. iterm_to_fterm (i x)))
[PROOF STEP]
fix x
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. \<And>x. \<theta> x \<cdot> i = fterm_to_iterm (iterm_to_fterm (\<theta> x) \<cdot>\<^sub>t (\<lambda>x. iterm_to_fterm (i x)))
[PROOF STEP]
show "\<theta> x \<cdot> i = fterm_to_iterm (iterm_to_fterm (\<theta> x) \<cdot>\<^sub>t (\<lambda>x. iterm_to_fterm (i x)))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<theta> x \<cdot> i = fterm_to_iterm (iterm_to_fterm (\<theta> x) \<cdot>\<^sub>t (\<lambda>x. iterm_to_fterm (i x)))
[PROOF STEP]
using iterm_to_fterm_subt
[PROOF STATE]
proof (prove)
using this:
iterm_to_fterm ?t1.0 \<cdot>\<^sub>t ?\<sigma> = iterm_to_fterm (?t1.0 \<cdot> (\<lambda>x. fterm_to_iterm (?\<sigma> x)))
goal (1 subgoal):
1. \<theta> x \<cdot> i = fterm_to_iterm (iterm_to_fterm (\<theta> x) \<cdot>\<^sub>t (\<lambda>x. iterm_to_fterm (i x)))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<theta> x \<cdot> i = fterm_to_iterm (iterm_to_fterm (\<theta> x) \<cdot>\<^sub>t (\<lambda>x. iterm_to_fterm (i x)))
goal:
No subgoals!
[PROOF STEP]
qed |
% last change: 2012-04-21
\input tex2page
\input plainsection
\let\TZPtexlayout 0
\let\n\noindent
\let\f\numberedfootnote
\ifx\shipout\toHTML
\let\oldsection\section
\def\section{\eject\oldsection}
\fi
\let\re\subsection
\advance\hoffset .75 true in
\advance\hsize -1.5 true in
\title{scmxlate}
%\ignorenextinputtimestamp
\centerline{\urlh{scmxlate.tar.bz2}{\ifx\shipout\totheWeb
Download \fi Version 20120421}} % last modified
\centerline{\urlh{../index.html}{Dorai Sitaram}}
\medskip
Scmxlate is a configuration tool for software
packages written in Scheme.
Scmxlate provides the package author with a strategy
for programmatically specifying the changes required to
translate the package for a variety of Scheme dialects
and Common Lisp, and a variety of operating systems.
The end-user simply loads {\em one} file into
their Scheme or Common Lisp, which triggers the entire
configuration process with little or no further
intervention.
Thus, there are two types of user for Scmxlate:
\item{\bull} The end-user of an Scmxlate-configured package, who
relies on the
Scmxlate program to perform the configuration
for their system; and
\item{\bull} the package author, who uses the Scmxlate
methodology to specify an executable form of the
configuration details for the package.
The package author is still required to know a lot more
about the configuration process than the end-user, even
with Scmxlate helping the former.
%(The Common Lisp half
%of Scmxlate uses \urlh{scm2cl.html}{Scm2cl},
%which is included in the Scmxlate distribution.)
The advantage to using Scmxlate is that the several
end-users can each configure the product to their
different systems by following the same simple
step.
Section~\ref{useconfig} describes the use of Scmxlate
to execute an already written configuration, and is all
the information you will need if you are an
end-user of packages that have Scmxlate configurations.
Sections~\ref{writeconfig} and \ref{glossary} are for
package authors, and describe the method and the
language used to write an Scmxlate configuration.
\bigbreak
\noindent{\bf Contents}
\tableofcontents
\ifx\shipout\totheWeb\else
\vfill\eject
\fi
\section{Using an Scmxlate configuration}
\label{useconfig}
Scenario: You are an end-user who has just downloaded a
Scheme package, say,
\urlh{../tex2page/tex2page-doc.html}{TeX2page}.
The package author claims to have included the Scmxlate
configuration details in the package. What do
you do?
First, you need to have Scmxlate installed on {\em
your} system. Get the \urlh{scmxlate.tar.gz}{Scmxlate tarball} and unpack
it, creating a directory called \p{scmxlate}. Place
this directory in its entirety in a place that is
convenient to you. Among the files in this directory
is the file \p{scmxlate.scm}. Note down
its {\em full} pathname so you can refer to it from
anywhere on your filesystem.
Just to make it concrete, let's assume you put the
\p{scmxlate} directory in \p{/usr/local/lib}. Then the
full pathname to remember is
\p{
/usr/local/lib/scmxlate/scmxlate.scm
}
Now to configure the TeX2page package. Unpack it
and \p{cd} to its directory.
For each Scheme file {\em filename} that is to be
translated, there may (but not necessarily) be a
user-configuration file \p{scmxlate-}{\em filename} in
the top directory. If the instructions that came with
the package suggest you edit them, do so. In our
example package, there is only one user-configuration
file, it is called \p{scmxlate-tex2page}, and it
doesn't seem to require any edits from the casual user.
Start your Scheme or Common Lisp in the top directory
(being in that directory is important!). In your
Scheme (or Common Lisp), type
\q{
(load "/usr/local/lib/scmxlate/scmxlate.scm")
}
\n where the \q{load} argument is of course the correct
pathname of the file \p{scmxlate.scm} for your
setup.
Scmxlate may ask you a few questions. A
choice of answers will be provided, so you don't need
to be too creative. When Scmxlate finishes, you
will be left with a version of the package tailormade
for you.
\section{Writing an Scmxlate configuration}
\label{writeconfig}
%{\color{red}\relax Nothing in this section is
%stable. The implementation and user interface is
%extremely likely to change in order to make the
%documentation easier to write.}
%
%In the following, we will assume that Scmxlate was
%unpacked in \p{/usr/local/lib}, so the full pathname of the
%\p{scmxlate.scm} file is
%\p{/usr/local/lib/scmxlate/scmxlate.scm}.
\subsection{A minimal configuration}
Let us say you have a number of Scheme files in
a directory that you intend to package as a
distribution. For specificity let's say the name of the
directory is \p{pkgdir} and you have three Scheme files in it,
viz, \p{apple}, \p{orange.scm}, and \p{banana.ss}.
There is no restriction on the names of these Scheme
files: They may have any or no extension. An end-user
of your distribution will unpack it to produce a
\p{pkgdir} of their own with the three Scheme files in
it.
Let us now say that you wrote the Scheme files in the
MzScheme dialect of Scheme, but that the end-user
uses the Guile dialect of Scheme. In order for them to
be able to create Guile versions of your files, you
need to provide in \p{pkgdir} some configuration
information. This can be done as follows:
Create a subdirectory called \p{dialects} in
\p{pkgdir}. In the \p{dialects} subdirectory,
create a file called \p{files-to-be-ported.scm}
containing the names of the Scheme files to be
translated, viz:
\q{
"apple"
"orange.scm"
"banana.ss"
}
\n and a file called \p{dialects-supported.scm} containing
the line
\q{
guile
}
\n The symbol \q{guile} of course stands for the Scheme
dialect Guile.
The Guile-using user can now start Guile in \p{pkgdir},
and load \p{scmxlate.scm} (using the appropriate
pathname for \p{scmxlate.scm} on their system, as
described in Section~\ref{useconfig}). Scmxlate will learn
from \path{dialects/files-to-be-ported.scm} that the files
\p{apple}, \p{orange.scm}, and \p{banana.ss} need to be
translated. It will ask the user what the dialect is,
offering as choices the dialects listed in
\path{dialects/dialects-supported.scm}, plus a catch-all
dialect called Other:\f{The astute reader may wonder
why Scmxlate needs to explicitly ask the user what the
target dialect is, when it is already running on it!
Unfortunately, since the Scxmlate code is necessarily
written in a style that must load in all Schemes, it
cannot portably determine the identity of the
particular Scheme dialect it is currently running on.}
\p{
What is your Scheme dialect?
(guile other)
}
The user types \p{guile} in response. Scmxlate now
understands that it is to create Guile translations of
the three files, and proceeds to do so. By default,
the translation-result files are created in the
\p{pkgdir} directory and have the same names as the
original but with the prefix \p{my-} attached. Thus,
in this case, their names are \p{my-apple},
\p{my-orange.scm}, and \p{my-banana.ss}.
In the following, we will for convenience use
the following terms:
\item{\bull} {\em input file}: a file to be translated;
\item{\bull} {\em output file}: a file that is the result of
a translation;
\item{\bull} {\em target dialect}: the dialect translated to.
\n In our example above, \p{apple} is an input
file, \p{my-apple} is its corresponding output file,
and Guile is the target dialect.
\subsection{Dialect-configuration files}
The output file \p{my-apple} above uses Scmxlate's
default rules for an MzScheme-to-Guile translation.
These rules are general and cannot be expected to cover
any peculiar translational information that may be
relevant to the code in \p{apple}. You can supply such
additional information to Scmxlate via a {\em
dialect-configuration file} called \p{guile-apple} in
the \p{dialects} subdirectory. Ie, the name of
the dialect-configuration file for a given input file
and a given dialect is formed from the Scmxlate symbol
for the dialect, followed by a hyphen, followed by the
name of the input file.
Scmxlate typically takes code from a
dialect-configuration file and sticks it ahead of the
translated code in the output file. This code can be
any Scheme code in the target dialect, and in
particular, it can include definitions. The order of
the code in the dialect-configuration file is preserved
in the output file.
For instance, if the MzScheme code in \p{apple} made
use of a nonstandard (MzScheme-only) primitive such as
\q{file-or-directory-modify-seconds}, we could supply
the following Guile definition in the
dialect-configuration file,
\path{dialects/guile-apple}:
\q{
(define file-or-directory-modify-seconds
(lambda (f) (vector-ref (stat f) 9)))
}
If the dialect-configuration file supplies a definition for
a name that is also defined in the input file,
then the output file will contain the definition from
the dialect-configuration file, not the input file.
For example, if \p{apple} contained
the definition
\q{
(define file-newer?
(lambda (f1 f2)
;checks if f1 is newer than f2
(> (file-or-directory-modify-seconds f1)
(file-or-directory-modify-seconds f2))))
}
\n we could put a competing Guile-specific definition
in \p{dialects/guile-apple}:
\q{
(define file-newer?
(lambda (f1 f2)
(> (vector-ref (stat f1) 9)
(vector-ref (stat f2) 9))))
}
\n When Scmxlate translates \p{apple}, it will directly
incorporate this Guile definition into the output file
\p{my-apple} and won't even attempt to translate
the MzScheme definition of the same name in the
input file.
\subsection{Target dialects}
In the above, we used the symbol \q{guile} in the
\p{dialects/dialects-supported.scm} file to signal to
Scmxlate that Guile is one of the dialects into which
the package can be translated. The list of dialect symbols
recognized by Scmxlate is: \q{bigloo}, \q{chez},
\q{cl},
\q{gambit}, \q{gauche}, \q{guile}, \q{kawa}, \q{mitscheme},
\q{mzscheme}, \q{other}, \q{petite}, \q{pscheme}, \q{scheme48},
\q{scm}, \q{sxm}, \q{scsh}, \q{stk}, \q{stklos},
\q{umbscheme}.
The symbols \q{mzscheme} and \q{plt}
may both be used for PLT Scheme: two symbols are
provided in case two distinct types of translations are
called for --- with \q{mzscheme} perhaps being used to create a
self-sufficient MzScheme script file, and \q{plt} to construct a
PLT module library.
The symbol \q{cl} stands for
Common Lisp.\f{Note that
Scmxlate can readily determine if it's running
on Common Lisp (as opposed to Scheme), so it will not query the user
for further ``dialect'' information.}
The symbol \q{other} can be used by the package author
to provide a default configuration for an unforeseen
dialect. Since the dialect is unknown, there isn't
much information to exploit, but it may be
possible to provide some bare-minimum functionality
(or at least display some advice).
The package author can make use of other symbols to
denote other Scheme dialects. However, as Scmxlate
cannot do any special translation for such dialects, it
is the responsibility of the package author to provide
additional configuration information for them by
writing dialect-configuration files.
\subsection{User-configuration files}
Some packages need some configuration information that
the package author cannot predict and that therefore
can come only come from the user. The information
typically contains user preferences for global
variables in the program. It should not be
dialect-specific.
Such user information can be placed in {\em
user-configuration files} in the package directory.
Each input file can have its own
user-configuration file, and the latter's name
consists of the prefix \p{scmxlate-} followed by the
name of the input file. Thus the user configuration
file for \p{orange.scm} is \p{scmxlate-orange.scm}.
While the package author may not be able to predict the
values of the globals preferred by their various
users, they can include in the package sample
user-configuration files that mention the globals
requiring the user's intervention, with comments
instructing how the user is to customize them.
Note that user-configuration code comes ahead of the
dialect-configuration code in the output file.
Definitions in the user-configuration code override
definitions in the dialect-configuration code, just
as the latter themselves override definitions in the
input file.
\section{The Scmxlate directives}
\label{glossary}
In addition to Scheme code intended to either augment
or override code in the input file, the
dialect- and user-configuration files can
use a small set of Scmxlate directives to finely control
the text that goes into the output file, and even
specify actions that go beyond the mere creation
of the output file. These directives are now described.
\re{{\tt scmxlate-insert}}
As we saw, Scheme code in the dialect- and
user-configuration files is transferred verbatim
to the output file. Sometimes, we need to put into the
output file arbitrary text that is not Scheme code.
For instance, we may want the output file to start with
a ``shell magic'' line, so that it can be used as a
shell script. Such text can be written using the
\p{scmxlate-insert} directive, which evaluates its
subforms in Scheme and displays them on the output
file.
Eg, if you put the following at
the very head of the \p{guile-apple} file:
\q{
(scmxlate-insert
"#!/bin/sh
exec guile -s $0 \"$@\"
!#
")
}
\n the output Guile file \p{my-apple} will start with the
line
\p{
#!/bin/sh
exec guile -s $0 "$@"
!#
}
Note that the order of the code and \q{scmxlate-insert}
text in the configuration file is preserved in
the output file.
\re{{\tt scmxlate-postamble}}
Typically, the Scheme code and \p{scmxlate-insert}s
specified in the dialect-configuration file occur in
the output file before the translated counterpart of
input file's contents, and thus may be considered as
{\em preamble} text. Sometimes we need to add {\em
postamble} text, ie, things that go {\em after} the
code from the input file. In order to do this,
place the directive
\q{
(scmxlate-postamble)
}
\n after any preamble text in the dialect-configuration
file. Everything following that, whether Scheme
code or \q{scmxlate-insert}s, will show up in the
output file after the translated contents of the input
file.
\re{{\tt scmxlate-postprocess}}
One can also specify actions that need to performed
after the output file has been written. Eg, let's say
we want the Guile output file for \p{apple} to be
named \p{pear} rather than \p{my-apple}. We can
enclose Scheme code for achieving this inside the
Scmxlate directive \q{scmxlate-postprocess}:
\q{
(scmxlate-postprocess
(rename-file "my-apple" "pear"))
}
\re{{\tt scmxlate-ignore-define}}
Sometimes the input file has a definition that the
target dialect does not need, either because the target
dialect already has it as a primitive, or because we
wish to completely re-write input code that uses that
definition. Eg, if the target dialect is MzScheme,
which already contains \q{reverse!}, any definition of
\q{reverse!} in the input file can be ignored.
\q{
(scmxlate-ignore-define reverse!)
}
\q{scmxlate-ignore-define} can have any number of
arguments. The definitions of all of them will be
ignored.
\re{{\tt scmxlate-rename}}
Sometimes we want to rename certain identifiers from
the input file. One possible motivation is that
these identifiers name nonstandard primitives that are
provided under a different name in the target dialect.
For instance, the Bigloo versions of the MzScheme
primitives \q{current-directory} and
\q{file-or-directory-modify-seconds} are \q{chdir} and
\q{file-modification-time} respectively. So if your
MzScheme input file uses \q{current-directory} and
\q{file-or-directory-modify-seconds}, your Bigloo
dialect-configuration file should contain
\q{
(scmxlate-rename
(current-directory chdir)
(file-or-directory-modify-seconds file-modification-time))
}
Note the syntax: \q{scmxlate-rename} has any number of
twosomes as arguments. The left item is the name in
the input file, and the right item is its proposed
replacement.
\re{{\tt scmxlate-rename-define}}
Sometimes the input file includes a definition
for an operator that the target dialect already has as
a primitive, but with a different name. Eg, consider
an input file that contains a definition for
\q{nreverse}. MzScheme has the same operator but with
name \q{reverse!}. You could add the following to
the MzScheme dialect-configuration file:
\q{
(scmxlate-rename-define
(nreverse reverse!))
}
Note that this is shorthand for
\q{
(scmxlate-ignore-define nreverse)
(scmxlate-rename
(nreverse reverse!))
}
\re{{\tt scmxlate-prefix}}
Another motivation for renaming is to avoid polluting
namespace. We may wish to have short names in the
input file, but when we configure it, we want longer,
``qualified'' names. It is possible to use
\q{scmxlate-rename} for this, but the
\q{scmxlate-prefix} is convenient when the newer names
are all uniformly formed by adding a prefix.
\q{
(scmxlate-prefix
"regexp::"
match
substitute
substitute-all)
}
\n renames the identifiers \q{match}, \q{substitute},
and \q{substitute-all} to
\q{regexp::match}, \q{regexp::substitute}, and
\q{regexp::substitute-all} respectively.
The first argument of \q{scmxlate-prefix} is the
string form of the prefix; the remaining arguments are
the identifiers that should be renamed.
\re{{\tt scmxlate-cond}}
Sometimes we want parts of the dialect-configuration
file to processed only when a condition holds. For
instance, we can use the following \q{cond}-like
conditional in
a dialect-configuration file for MzScheme to
write out a shell-magic
line appropriate to the operating system:
\q{
(scmxlate-cond
((eqv? (system-type) 'unix)
(scmxlate-insert *unix-shell-magic-line*))
((eqv? (system-type) 'windows)
(scmxlate-insert *windows-shell-magic-line*)))
}
\n where \q{*unix-shell-magic-line*} and
\q{*windows-shell-magic-line*} are replaced by
appropriate strings.
Note that while \q{scmxlate-cond} allows the \q{else}
keyword for its final clause, it does not support the
Scheme \q{cond}'s \q{=>} keyword.
\re{{\tt scmxlate-eval}}
The test argument of \q{scmxlate-cond} and all the
arguments of \q{scmxlate-insert} are evaluated in the
Scheme global environment when Scmxlate is running.
You can enhance this environment with
\q{scmxlate-eval}. Thus, if we had
\q{
(scmxlate-eval
(define *unix-shell-magic-line* <...>)
(define *windows-shell-magic-line* <...>))
}
\n where the \q{<...>} stand for code that constructs
the appropriate string, then we could use these
variables as the arguments to \q{scmxlate-insert} in
the example under \q{scmxlate-cond}.
\q{scmxlate-eval} can have any number of subforms.
It evaluates each of them in the given order.
\re{{\tt scmxlate-compile}}
\q{scmxlate-compile} can be used to tell if the output
file is to be compiled. Typical usage is
\q{
(scmxlate-compile #t) ;or
(scmxlate-compile #f)
}
\n The first forces compilation but only if the dialect
supports it, and the second disables compilation even
if the dialect supports it. The argument of
\q{scmxlate-compile} can be any expression, which is
evaluated only for its boolean significance.
Without a \q{scmxlate-compile} setting, Scmxlate will
ask the user explicitly for advice, but only if
the dialect supports compilation.
\re{{\tt scmxlate-include}}
It is often convenient to keep in a separate file some
of the portions of the text that should go into a
dialect-configuration file. Some definitions may
naturally be already written down somewhere else, or
we may want the text to be shared across several
dialect-configuration files (for different dialects).
The call
\q{
(scmxlate-include "filename")
}
\n inserts the contents of \q{"filename"}
into that location in the dialect-configuration file.
\re{{\tt scmxlate-uncall}}
It is sometimes necessary to skip a top-level
call when translating an input file. For instance,
the input file may be used as a script file whose
scriptural action consists in calling a procedure
called \q{main}. The target dialect may not allow
the output file to be a script, so the user may prefer
to load the output file into Scheme as a library
and make other arrangements to invoke its
functionality. To disable the call to \q{main}
in the output file, add
\q{
(scmxlate-uncall main)
}
\n to the configuration file.
\q{scmxlate-uncall} can take any number of symbol
arguments. All the corresponding top-level calls
will be disabled in the output.
\bye
Some rejected crap follows.
Only two of these symbols need special explanation: A
user can pick the \p{other} dialect if his Scheme isn't
listed in the choices that Scmxlate offers. The
dialect \p{cl} isn't a Scheme dialect but Common Lisp.
Scheme dialects do identified by human
intervention, as there is (yet) no portable Scheme code
to id the dialect.
More than one file can be configured using
Scmxlate. Just add the filenames to
\p{dialects/files-to-be-ported.scm}. Customizing info
tailored to each file can be added to the \p{dialects}
directory as we have already described for the
file \p{progfile}. Ie, an Scsh customization file
for \p{anotherfile.ss} would be
\p{dialects/scsh-anotherfile.ss}.
\iffalse
This kind of definition replacement is particularly
useful when the target language is Common Lisp.
For instance, let's say \p{progfile} contains
the definition
\q{
(define lassoc
(lambda (k al equ?)
(let loop ((al al))
(if (null? al) #f
(let ((c (car al)))
(if (equ? (car c) k) c
(loop (cdr al))))))))
}
Scmxlate will provide a complicated if working
Common Lisp translation of the above code, but it
will not be as simple as
\q{
(defun lassoc (k al equ?)
(assoc k al :test equ?))
}
You can put this latter definition in
\p{dialects/cl-progfile} -- where the symbol \q{cl}
stands for Common Lisp -- and it will be used in
preference to the default translation.
\fi
You may wish for some extra CL code to precede or
follow the translated \p{progfile} code. For instance,
you may wish to add some additional definitions before
the translation to cover some MzScheme-specific
procedures you may have used in \p{progfile}. Eg,
\q{
(defun getenv (ev)
(system::getenv ev))
}
\n This can be placed in the file
\p{dialects/cl-preamble-progfile}.
CL code you want following the \p{progfile} code can be
placed in \p{dialects/cl-postamble-progfile}.
\subsection{Specifying Scheme dialects}
The filename prefix \p{cl-} used in the previous
example is used to identify configuration info
for Common Lisp. If the target language is another
Scheme dialect, rather than Common Lisp, you can follow
a similar procedure, except that we need some way for
the target Scheme to identify itself to Scmxlate.
Scmxlate can tell if it is running in CL, but
needs help in determining which particular Scheme
dialect it is running.
For example, let's say the target Scheme dialect
is Guile. We create in \p{dialects} a file called
\p{dialects-supported.scm} containing the line
\p{
guile
}
Now if the user starts Guile in the \p{pkgdir}
directory and loads \p{scmxlate.scm}, the following
question will be asked:
\p{
What is your Scheme dialect?
(guile other)
}
Typing \p{guile} in response will cause Scmxlate to
create a \p{my-progfile} that is the Guile translation
of \p{progfile}. You can add additional Guile
configuration info in the form of the files
\p{guile-preamble-progfile}, \p{guile-procs-progfile},
and \p{guile-postamble-progfile}, exactly as for CL
above.
The user can use the symbol \p{other} if his Scheme
dialect is not listed in \p{dialects-supported.scm} but
he wants to configure the package anyway. The results
may be variable. The configurer can also put in
additional config info in the \p{dialects}
directory using the \p{other-} prefix.
You can certainly add a symbol of your own in
\p{dialects-supported.scm}. Scmxlate will not know
of it by default, but you can add additional
configuration files using the appropriate prefix in
\p{dialects}.
\subsection{Configuring more than one file}
You can of course configure more than one \p{progfile}.
Simply add their names to the
\p{dialects/files-to-be-ported.scm} directory. By
default, the translated files will have the same names
as the originals, but with the prefix \p{my-} in front
of them.
\subsection{To be described}
Scmxlate-specific commands used in the
configuration files:
user-override-file
operating-system dependencies
Let us say you wrote a Scheme file named
\p{progfile}\f{The Scheme file's name may have no or
any extension. Thus, \p{newton-raphson},
\p{newton-raphson~}, \p{newton-raphson.bak},
\p{newton-raphson.scm}, \p{newton-raphson.ss},
\p{newton-raphson.java} are all acceptable filenames
--- but the file's contents must be Scheme code.} in a
directory \p{pkgdir}, and you package it off into a
distribution which an end-user will unpack to
produce a directory \p{pkgdir} of his own.
|
lemma Bfun_def: "Bfun f F \<longleftrightarrow> (\<exists>K>0. eventually (\<lambda>x. norm (f x) \<le> K) F)" |
/-
Copyright (c) 2020 Fox Thomson. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Fox Thomson
-/
import data.list.join
import data.set.lattice
/-!
# Languages
This file contains the definition and operations on formal languages over an alphabet. Note strings
are implemented as lists over the alphabet.
The operations in this file define a [Kleene algebra](https://en.wikipedia.org/wiki/Kleene_algebra)
over the languages.
-/
open list set
universes v
variables {Ξ± Ξ² Ξ³ : Type*}
/-- A language is a set of strings over an alphabet. -/
@[derive [has_mem (list Ξ±), has_singleton (list Ξ±), has_insert (list Ξ±), complete_boolean_algebra]]
def language (Ξ±) := set (list Ξ±)
namespace language
variables {l m : language Ξ±} {a b x : list Ξ±}
local attribute [reducible] language
/-- Zero language has no elements. -/
instance : has_zero (language Ξ±) := β¨(β
: set _)β©
/-- `1 : language Ξ±` contains only one element `[]`. -/
instance : has_one (language Ξ±) := β¨{[]}β©
instance : inhabited (language Ξ±) := β¨0β©
/-- The sum of two languages is their union. -/
instance : has_add (language Ξ±) := β¨(βͺ)β©
/-- The product of two languages `l` and `m` is the language made of the strings `x ++ y` where
`x β l` and `y β m`. -/
instance : has_mul (language Ξ±) := β¨image2 (++)β©
lemma zero_def : (0 : language Ξ±) = (β
: set _) := rfl
lemma one_def : (1 : language Ξ±) = {[]} := rfl
lemma add_def (l m : language Ξ±) : l + m = l βͺ m := rfl
lemma mul_def (l m : language Ξ±) : l * m = image2 (++) l m := rfl
/-- The star of a language `L` is the set of all strings which can be written by concatenating
strings from `L`. -/
def star (l : language Ξ±) : language Ξ± :=
{ x | β S : list (list Ξ±), x = S.join β§ β y β S, y β l}
lemma star_def (l : language Ξ±) :
l.star = { x | β S : list (list Ξ±), x = S.join β§ β y β S, y β l} := rfl
@[simp] lemma not_mem_zero (x : list Ξ±) : x β (0 : language Ξ±) := id
@[simp] lemma mem_one (x : list Ξ±) : x β (1 : language Ξ±) β x = [] := by refl
lemma nil_mem_one : [] β (1 : language Ξ±) := set.mem_singleton _
@[simp] lemma mem_add (l m : language Ξ±) (x : list Ξ±) : x β l + m β x β l β¨ x β m := iff.rfl
lemma mem_mul : x β l * m β β a b, a β l β§ b β m β§ a ++ b = x := mem_image2
lemma append_mem_mul : a β l β b β m β a ++ b β l * m := mem_image2_of_mem
lemma mem_star : x β l.star β β S : list (list Ξ±), x = S.join β§ β y β S, y β l := iff.rfl
lemma join_mem_star {S : list (list Ξ±)} (h : β y β S, y β l) : S.join β l.star := β¨S, rfl, hβ©
lemma nil_mem_star (l : language Ξ±) : [] β l.star := β¨[], rfl, Ξ» _, false.elimβ©
instance : semiring (language Ξ±) :=
{ add := (+),
add_assoc := union_assoc,
zero := 0,
zero_add := empty_union,
add_zero := union_empty,
add_comm := union_comm,
mul := (*),
mul_assoc := Ξ» _ _ _, image2_assoc append_assoc,
zero_mul := Ξ» _, image2_empty_left,
mul_zero := Ξ» _, image2_empty_right,
one := 1,
one_mul := Ξ» l, by simp [mul_def, one_def],
mul_one := Ξ» l, by simp [mul_def, one_def],
nat_cast := Ξ» n, if n = 0 then 0 else 1,
nat_cast_zero := rfl,
nat_cast_succ := Ξ» n, by cases n; simp [nat.cast, add_def, zero_def],
left_distrib := Ξ» _ _ _, image2_union_right,
right_distrib := Ξ» _ _ _, image2_union_left }
@[simp] lemma add_self (l : language Ξ±) : l + l = l := sup_idem
/-- Maps the alphabet of a language. -/
def map (f : Ξ± β Ξ²) : language Ξ± β+* language Ξ² :=
{ to_fun := image (list.map f),
map_zero' := image_empty _,
map_one' := image_singleton,
map_add' := image_union _,
map_mul' := Ξ» _ _, image_image2_distrib $ map_append _ }
@[simp] lemma map_id (l : language Ξ±) : map id l = l := by simp [map]
@[simp] lemma map_map (g : Ξ² β Ξ³) (f : Ξ± β Ξ²) (l : language Ξ±) : map g (map f l) = map (g β f) l :=
by simp [map, image_image]
lemma star_def_nonempty (l : language Ξ±) :
l.star = {x | β S : list (list Ξ±), x = S.join β§ β y β S, y β l β§ y β []} :=
begin
ext x,
split,
{ rintro β¨S, rfl, hβ©,
refine β¨S.filter (Ξ» l, Β¬list.empty l), by simp, Ξ» y hy, _β©,
rw [mem_filter, empty_iff_eq_nil] at hy,
exact β¨h y hy.1, hy.2β© },
{ rintro β¨S, hx, hβ©,
exact β¨S, hx, Ξ» y hy, (h y hy).1β© }
end
lemma le_mul_congr {lβ lβ mβ mβ : language Ξ±} : lβ β€ mβ β lβ β€ mβ β lβ * lβ β€ mβ * mβ :=
begin
intros hβ hβ x hx,
simp only [mul_def, exists_and_distrib_left, mem_image2, image_prod] at hx β’,
tauto
end
lemma le_add_congr {lβ lβ mβ mβ : language Ξ±} : lβ β€ mβ β lβ β€ mβ β lβ + lβ β€ mβ + mβ := sup_le_sup
lemma mem_supr {ΞΉ : Sort v} {l : ΞΉ β language Ξ±} {x : list Ξ±} :
x β (β¨ i, l i) β β i, x β l i :=
mem_Union
lemma supr_mul {ΞΉ : Sort v} (l : ΞΉ β language Ξ±) (m : language Ξ±) :
(β¨ i, l i) * m = β¨ i, l i * m :=
image2_Union_left _ _ _
lemma mul_supr {ΞΉ : Sort v} (l : ΞΉ β language Ξ±) (m : language Ξ±) :
m * (β¨ i, l i) = β¨ i, m * l i :=
image2_Union_right _ _ _
lemma supr_add {ΞΉ : Sort v} [nonempty ΞΉ] (l : ΞΉ β language Ξ±) (m : language Ξ±) :
(β¨ i, l i) + m = β¨ i, l i + m := supr_sup
lemma add_supr {ΞΉ : Sort v} [nonempty ΞΉ] (l : ΞΉ β language Ξ±) (m : language Ξ±) :
m + (β¨ i, l i) = β¨ i, m + l i := sup_supr
lemma mem_pow {l : language Ξ±} {x : list Ξ±} {n : β} :
x β l ^ n β β S : list (list Ξ±), x = S.join β§ S.length = n β§ β y β S, y β l :=
begin
induction n with n ihn generalizing x,
{ simp only [mem_one, pow_zero, length_eq_zero],
split,
{ rintro rfl, exact β¨[], rfl, rfl, Ξ» y h, h.elimβ© },
{ rintro β¨_, rfl, rfl, _β©, refl } },
{ simp only [pow_succ, mem_mul, ihn],
split,
{ rintro β¨a, b, ha, β¨S, rfl, rfl, hSβ©, rflβ©,
exact β¨a :: S, rfl, rfl, forall_mem_cons.2 β¨ha, hSβ©β© },
{ rintro β¨_|β¨a, Sβ©, rfl, hn, hSβ©; cases hn,
rw forall_mem_cons at hS,
exact β¨a, _, hS.1, β¨S, rfl, rfl, hS.2β©, rflβ© } }
end
lemma star_eq_supr_pow (l : language Ξ±) : l.star = β¨ i : β, l ^ i :=
begin
ext x,
simp only [mem_star, mem_supr, mem_pow],
split,
{ rintro β¨S, rfl, hSβ©, exact β¨_, S, rfl, rfl, hSβ© },
{ rintro β¨_, S, rfl, rfl, hSβ©, exact β¨S, rfl, hSβ© }
end
@[simp] lemma map_star (f : Ξ± β Ξ²) (l : language Ξ±) : map f (star l) = star (map f l) :=
begin
rw [star_eq_supr_pow, star_eq_supr_pow],
simp_rw βmap_pow,
exact image_Union,
end
lemma mul_self_star_comm (l : language Ξ±) : l.star * l = l * l.star :=
by simp only [star_eq_supr_pow, mul_supr, supr_mul, β pow_succ, β pow_succ']
@[simp] lemma one_add_self_mul_star_eq_star (l : language Ξ±) : 1 + l * l.star = l.star :=
begin
simp only [star_eq_supr_pow, mul_supr, β pow_succ, β pow_zero l],
exact sup_supr_nat_succ _
end
@[simp] lemma one_add_star_mul_self_eq_star (l : language Ξ±) : 1 + l.star * l = l.star :=
by rw [mul_self_star_comm, one_add_self_mul_star_eq_star]
lemma star_mul_le_right_of_mul_le_right (l m : language Ξ±) : l * m β€ m β l.star * m β€ m :=
begin
intro h,
rw [star_eq_supr_pow, supr_mul],
refine supr_le _,
intro n,
induction n with n ih,
{ simp },
rw [pow_succ', mul_assoc (l^n) l m],
exact le_trans (le_mul_congr le_rfl h) ih,
end
lemma star_mul_le_left_of_mul_le_left (l m : language Ξ±) : m * l β€ m β m * l.star β€ m :=
begin
intro h,
rw [star_eq_supr_pow, mul_supr],
refine supr_le _,
intro n,
induction n with n ih,
{ simp },
rw [pow_succ, βmul_assoc m l (l^n)],
exact le_trans (le_mul_congr h le_rfl) ih
end
end language
|
module Issue117 where
Setβ² = Set
record β€ : Setβ² where
data β₯ : Setβ² where
|
If $X$ is an increasing sequence of real numbers and $X_i \leq B$ for all $i$, then $X$ is bounded. |
{-# OPTIONS --without-K #-}
module sets.empty where
open import level using ()
data β₯ : Set where
β₯-elim : β {i}{A : Set i} β β₯ β A
β₯-elim ()
Β¬_ : β {i} β Set i β Set i
Β¬ X = X β β₯
infix 3 Β¬_
|
State Before: R : Type u
S : Type v
a b c d : R
nβ m : β
instβ : Semiring R
pβ q r p : R[X]
n : β
hp : p β 0
β’ degree p = βn β natDegree p = n State After: R : Type u
S : Type v
a b c d : R
nβ m : β
instβ : Semiring R
pβ q r p : R[X]
n : β
hp : p β 0
β’ β(natDegree p) = βn β natDegree p = n Tactic: rw [degree_eq_natDegree hp] State Before: R : Type u
S : Type v
a b c d : R
nβ m : β
instβ : Semiring R
pβ q r p : R[X]
n : β
hp : p β 0
β’ β(natDegree p) = βn β natDegree p = n State After: no goals Tactic: exact WithBot.coe_eq_coe |
function nav=adjnav(nav,opt)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%adjust the wavelength of priority frequencies for BDS2 and BDS3
%eph and geph struct to eph and geph matrix
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
global glc
%adjust eph
if nav.n>0
eph0=zeros(nav.n,40);
for i=1:nav.n
eph=nav.eph(i);
eph0(i,:)=[eph.sat, eph.iode, eph.iodc, eph.sva, eph.svh, eph.week, eph.code, eph.flag, eph.toc.time, eph.toc.sec,...
eph.toe.time, eph.toe.sec, eph.ttr.time, eph.ttr.sec, eph.A, eph.e, eph.i0, eph.OMG0, eph.omg, eph.M0,...
eph.deln, eph.OMGd, eph.idot, eph.crc, eph.crs, eph.cuc, eph.cus, eph.cic, eph.cis, eph.toes,...
eph.fit, eph.f0, eph.f1, eph.f2, eph.tgd, eph.Adot, eph.ndot];
end
nav=rmfield(nav,'eph');
nav.eph=eph0;
end
%adjust geph
if nav.ng>0
geph0=zeros(nav.ng,22);
for i=1:nav.ng
geph=nav.geph(i);
geph0(i,:)=[geph.sat, geph.iode, geph.frq, geph.svh, geph.sva, geph.age, geph.toe.time, geph.toe.sec, geph.tof.time, geph.tof.sec,...
geph.pos', geph.vel', geph.acc', geph.taun,...
geph.gamn, geph.dtaun];
end
nav=rmfield(nav,'geph');
nav.geph=geph0;
end
% adjust wavelength
bds_frq_flag=1;
lam=nav.lam; nav=rmfield(nav,'lam'); nav.lam=zeros(glc.MAXSAT,glc.NFREQ);
if glc.NFREQ>3&&(size(opt.bd2frq,2)<=3||size(opt.bd3frq,2)<=3)&&~isempty(strfind(opt.navsys,'C'))
bds_frq_flag=0;
fprintf('Warning:Specified frequency of BDS less than used number of frequency!\n');
end
for i=1:glc.MAXSAT
[sys,prn]=satsys(i);
if sys==glc.SYS_BDS
if prn<19 %BD2
if ~bds_frq_flag,continue;end
frq=opt.bd2frq;
for j=1:glc.NFREQ
nav.lam(i,j)=lam(i,frq(j));
end
else %BD3
if ~bds_frq_flag,continue;end
frq=opt.bd3frq;
for j=1:glc.NFREQ
nav.lam(i,j)=lam(i,frq(j));
end
end
else %GPS GLO GAL QZS
nav.lam(i,:)=lam(i,1:3);
end
end
return
|
#define int_p_NULL NULL
#include <iostream>
#include <boost/any.hpp>
#include <boost/atomic.hpp>
#include <boost/bimap.hpp>
#include <boost/chrono.hpp>
#include <boost/circular_buffer.hpp>
#include <boost/container/deque.hpp>
#include <boost/container/flat_map.hpp>
#include <boost/container/flat_set.hpp>
#include <boost/container/list.hpp>
#include <boost/container/map.hpp>
#include <boost/container/set.hpp>
#include <boost/container/slist.hpp>
#include <boost/container/stable_vector.hpp>
#include <boost/container/string.hpp>
#include <boost/container/vector.hpp>
#include <boost/date_time.hpp>
#include <boost/dynamic_bitset.hpp>
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <boost/gil/rgb.hpp>
#include <boost/gil/extension/io/png.hpp>
#include <boost/interprocess/offset_ptr.hpp>
#include <boost/intrusive/list.hpp>
#include <boost/intrusive/set.hpp>
#include <boost/intrusive/slist.hpp>
#include <boost/logic/tribool.hpp>
#include <boost/make_shared.hpp>
#include <boost/multi_array.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/vector_sparse.hpp>
#include <boost/optional.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/ptr_container/ptr_array.hpp>
#include <boost/ptr_container/ptr_deque.hpp>
#include <boost/ptr_container/ptr_list.hpp>
#include <boost/ptr_container/ptr_map.hpp>
#include <boost/ptr_container/ptr_set.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/rational.hpp>
#include <boost/regex.hpp>
#include <boost/scoped_array.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/utility/string_view.hpp>
#include <boost/utility/string_ref.hpp>
#include <boost/utility/value_init.hpp>
#include <boost/variant.hpp>
#include <boost/weak_ptr.hpp>
#include <gsl/gsl>
void TestAtomic()
{
boost::atomic_flag f;
f.test_and_set();
boost::atomic<int> a(5);
}
class Data
{
public:
Data() : s(3), f(7.77f) {}
int s;
float f;
void Test() {}
};
void mallocDeleter(Data*& ptr)
{
if (ptr)
{
delete ptr;
ptr=NULL;
}
}
void TestPointerContainerLibrary()
{
boost::ptr_array<boost::nullable<Data>, 10> b;
b.replace(0, new Data());
for(auto it = b.begin(); it!=b.end();it++)
(*it);
boost::ptr_vector<boost::nullable<Data>> d;
d.push_back(new Data());
d.push_back(0);
for(auto it = d.begin(); it!=d.end();it++)
(*it);
boost::ptr_map<int, Data> e;
int ival = 33;
e.insert(ival, new Data());
for(auto it = e.begin(); it!=e.end();it++)
(*it);
boost::ptr_list<Data> g;
g.push_back(new Data());
for(auto it = g.begin(); it!=g.end();it++)
(*it);
boost::ptr_deque<Data> h;
h.push_back(new Data());
for(auto it = h.begin(); it!=h.end();it++)
(*it);
boost::ptr_set<int> i;
i.insert(new int(5));
for(auto it = i.begin(); it!=i.end();it++)
(*it);
boost::ptr_multimap<int, Data> k;
k.insert(ival, new Data());
for(auto it = k.begin(); it!=k.end();it++)
(*it);
boost::ptr_multiset<int> l;
l.insert(new int(5));
for(auto it = l.begin(); it!=l.end();it++)
(*it);
}
void TestGil()
{
try
{
using namespace boost::gil;
rgb8_image_t img;
read_and_convert_image("test_image.png", img, png_tag());
using my_images_t = boost::mp11::mp_list<gray8_image_t, rgb8_image_t, gray16_image_t, rgb16_image_t>;
any_image<my_images_t> dyn_img;
read_image("test_image.png", dyn_img, png_tag());
auto view = flipped_up_down_view(const_view(dyn_img));
}
catch (std::ios_base::failure)
{
}
}
void TestGregorian()
{
using namespace boost::gregorian;
date weekstart(2002,Feb,1);
date_duration duration = weeks(1);
date weekend = weekstart + weeks(1);
date d1 = day_clock::local_day();
date d2 = d1 + days(5);
if (d2 >= d1) {} //date comparison operators
date_period thisWeek(d1,d2);
if (thisWeek.contains(d1)) {}//do something
//iterate and print the week
day_iterator itr(weekstart);
while (itr <= weekend) {
++itr;
}
//US labor day is first Monday in Sept
typedef nth_day_of_the_week_in_month nth_dow;
nth_dow labor_day(nth_dow::first, Monday, Sep);
labor_day.to_string();
//calculate a specific date for 2004 from functor
date d3 = labor_day.get_date(2004);
auto ds = to_simple_string(weekstart);
auto ds3 = to_simple_string(d3);
}
void TestPosixTime()
{
using namespace boost::posix_time;
boost::gregorian::date d(2002, boost::date_time::Feb, 1); //an arbitrary date
ptime t1(d, hours(5) + millisec(100)); //date + time of day offset
ptime t2 = t1 - minutes(4) + seconds(2);
ptime now = second_clock::local_time(); //use the clock
boost::gregorian::date today = now.date(); //Get the date part out of the time
boost::gregorian::date tomorrow = today + boost::gregorian::date_duration(1);
ptime tomorrow_start(tomorrow); //midnight
auto ts = boost::posix_time::to_simple_string(tomorrow_start);
//starting at current time iterator adds by one hour
time_iterator titr(now, hours(1));
for (; titr < tomorrow_start; ++titr) {
}
}
void TestLocalTime()
{
using namespace boost::local_time;
using namespace boost::date_time;
//setup some timezones for creating and adjusting times
//first time zone uses the time zone file for regional timezone definitions
tz_database tz_db;
//tz_db.load_from_file("date_time_zonespec.csv");
time_zone_ptr nyc_tz = tz_db.time_zone_from_region("America/New_York");
//This timezone uses a posix time zone string definition to create a time zone
posix_time_zone timezone("MST-07:00:00");
time_zone_ptr phx_tz(new posix_time_zone("MST-07:00:00"));
//local departure time in phoenix is 11 pm on April 2 2005
// Note that New York changes to daylight savings on Apr 3 at 2 am)
local_date_time phx_departure(boost::gregorian::date(2005, Apr, 2), boost::posix_time::hours(23), phx_tz,
local_date_time::NOT_DATE_TIME_ON_ERROR);
boost::posix_time::time_duration flight_length = boost::posix_time::hours(4) + boost::posix_time::minutes(30);
local_date_time phx_arrival = phx_departure + flight_length;
//convert the phx time to a nyz time
local_date_time nyc_arrival = phx_arrival.local_time_in(nyc_tz);
auto tzs = timezone.to_posix_string();
auto tds = boost::posix_time::to_simple_string(flight_length);
}
void TestContainers()
{
boost::dynamic_bitset<> x(70);
x[0] = 1;
x[1] = 1;
x[4] = 1;
boost::array<Data, 10> a;
a[0] = Data();
auto r = boost::addressof(a);
boost::circular_buffer<int> cb(3);
// Insert some elements into the buffer.
cb.push_back(1);
cb.push_back(2);
cb.push_back(3);
cb.push_back(4);
for(boost::circular_buffer<int>::const_iterator it = cb.begin(); it!=cb.end();it++)
(*it);
using namespace boost::container;
vector<int> v;
v.push_back(100);
for (vector<int>::const_iterator it = v.cbegin(); it != v.cend(); it++)
(*it);
stable_vector<int> sv;
sv.push_back(100);
for (stable_vector<int>::const_iterator it = sv.cbegin(); it != sv.cend(); it++)
(*it);
deque<int> d;
d.push_back(100);
for (deque<int>::const_iterator it = d.begin(); it != d.end();it++)
(*it);
flat_map<int, int> fm;
fm.insert(std::make_pair(100, 1000));
for(flat_map<int, int>::const_iterator it = fm.begin(); it!=fm.end();it++)
(*it);
flat_set<int> fs;
fs.insert(100);
for(flat_set<int>::const_iterator it = fs.begin(); it!=fs.end();it++)
(*it);
// use intrusive data
list<int> l;
l.push_back(100);
for (auto it = l.cbegin(); it != l.cend(); it++)
*it;
slist<int> sl;
sl.push_front(100);
for(slist<int>::const_iterator it = sl.begin(); it!=sl.end();it++)
(*it);
map<int, int> m;
m[100] = 1000;
for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
(*it);
set<int> s;
s.insert(100);
for(set<int>::const_iterator it = s.begin(); it!=s.end();it++)
(*it);
basic_string<char> str("dsfsdf");
basic_string<char> str2("lk;lgdfkg;lka;glk''l;'sfgllllllllllllllllllllllllllllllllllll;f");
basic_string<wchar_t> wstr(L"dsfsdf");
basic_string<wchar_t> wstr2(L"lk;lgdfkg;lka;glk''l;'sfgllllllllllllllllllllllllllllllllllll;f");
}
void TestInterprocess()
{
using namespace boost::interprocess;
struct structure
{
int integer1; //The compiler places this at offset 0 in the structure
offset_ptr<int> ptr; //The compiler places this at offset 4 in the structure
int integer2; //The compiler places this at offset 8 in the structure
};
structure s;
s.integer1 = 33;
s.integer2 = 77;
//Assign the address of "integer1" to "ptr".
//"ptr" will store internally "-4":
// (char*)&s.integer1 - (char*)&s.ptr;
s.ptr = &s.integer1;
//Assign the address of "integer2" to "ptr".
//"ptr" will store internally "4":
// (char*)&s.integer2 - (char*)&s.ptr;
s.ptr = &s.integer2;
}
class MyClass : public boost::intrusive::list_base_hook<> //This is a derivation hook
{
int int_;
public:
//This is a member hook
boost::intrusive::list_member_hook<> member_hook_;
MyClass(int i)
: int_(i)
{}
};
//This is a base hook
class MyClassS : public boost::intrusive::slist_base_hook<>
{
int int_;
public:
//This is a member hook
boost::intrusive::slist_member_hook<> member_hook_;
MyClassS(int i)
: int_(i)
{}
};
void TestIntrusiveList()
{
//Define a list that will store MyClass using the public base hook
typedef boost::intrusive::list<MyClass> BaseList;
//Define a list that will store MyClass using the public member hook
typedef boost::intrusive::list< MyClass
, boost::intrusive::member_hook< MyClass, boost::intrusive::list_member_hook<>, &MyClass::member_hook_>
> MemberList;
using namespace boost::intrusive;
BaseList baselist;
MyClass val1(100);
//Now insert them in the reverse order in the base hook list
baselist.push_front(val1);
for (auto it = baselist.begin(); it != baselist.end(); it++)
{
*it;
}
MemberList memberlist;
MyClass val2(100);
//Now insert them in the same order as in vector in the member hook list
memberlist.push_back(val2);
for (auto it = memberlist.begin(); it != memberlist.end(); it++)
{
*it;
}
//Define an slist that will store MyClass using the public base hook
typedef slist<MyClassS> BaseListS;
//Define an slist that will store MyClass using the public member hook
typedef member_hook<MyClassS, slist_member_hook<>, &MyClassS::member_hook_> MemberOptionS;
typedef slist<MyClassS, MemberOptionS> MemberListS;
BaseListS baselists;
MyClassS vals1(200);
//Now insert them in the reverse order in the base hook list
baselists.push_front(vals1);
for (auto it = baselists.begin(); it != baselists.end(); it++)
{
*it;
}
MemberListS memberlists;
MyClassS vals2(300);
//Now insert them in the same order as in vector in the member hook list
memberlists.push_front(vals2);
for (auto it = memberlists.begin(); it != memberlists.end(); it++)
{
*it;
}
// Clearing the containers means we avoid the boost debug assertion for
// a safe_link hook that checks whether the contained object is still
// linked to a container when the object is deleted.
baselists.clear();
memberlists.clear();
baselist.clear();
memberlist.clear();
}
struct Belem : public boost::intrusive::set_base_hook<>
{
int mval;
Belem(int val) : mval(val) {}
bool operator<(const Belem& other) const { return mval < other.mval; }
bool operator>(const Belem& other) const { return mval > other.mval; }
bool operator==(const Belem& other) const { return mval == other.mval; }
};
void TestIntrusiveSet_BaseHook()
{
typedef boost::intrusive::set<Belem> Container;
Container container;
Belem belem1(1);
Belem belem2(2);
container.insert(belem1);
container.insert(belem2);
Container::iterator itr = container.begin();
Container::const_iterator citr = container.begin();
Container::iterator enditr = container.end();
container.clear();
}
struct Melem
{
int mval;
boost::intrusive::set_member_hook<> mhook;
Melem(int val) : mval(val) {}
bool operator<(const Melem& other) const { return mval < other.mval; }
bool operator>(const Melem& other) const { return mval > other.mval; }
bool operator==(const Melem& other) const { return mval == other.mval; }
};
void TestIntrusiveSet_MemberHook()
{
typedef boost::intrusive::member_hook<Melem, boost::intrusive::set_member_hook<>, &Melem::mhook> MemberHookOptions;
typedef boost::intrusive::set<Melem, MemberHookOptions> MContainer;
MContainer container;
Melem melem1(1);
Melem melem2(2);
container.insert(melem1);
container.insert(melem2);
MContainer::iterator itr = container.begin();
MContainer::const_iterator citr = container.begin();
container.clear();
}
struct Belem_NoSz : public boost::intrusive::set_base_hook<>
{
int mval;
Belem_NoSz(int val) : mval(val) {}
bool operator<(const Belem_NoSz& other) const { return mval < other.mval; }
bool operator>(const Belem_NoSz& other) const { return mval > other.mval; }
bool operator==(const Belem_NoSz& other) const { return mval == other.mval; }
};
void TestIntrusiveSet_BaseHook_NoSizeMember()
{
typedef boost::intrusive::set<Belem_NoSz, boost::intrusive::constant_time_size<false> > Container_NoSz;
Container_NoSz container;
Belem_NoSz belem1(1);
Belem_NoSz belem2(2);
container.insert(belem1);
container.insert(belem2);
Container_NoSz::iterator itr = container.begin();
Container_NoSz::const_iterator citr = container.begin();
container.clear();
}
struct Melem_NoSz
{
int mval;
boost::intrusive::set_member_hook<> mhook;
Melem_NoSz(int val) : mval(val) {}
bool operator<(const Melem_NoSz& other) const { return mval < other.mval; }
bool operator>(const Melem_NoSz& other) const { return mval > other.mval; }
bool operator==(const Melem_NoSz& other) const { return mval == other.mval; }
};
void TestIntrusiveSet_MemberHook_NoSizeMember()
{
typedef boost::intrusive::member_hook<Melem_NoSz, boost::intrusive::set_member_hook<>, &Melem_NoSz::mhook> MemberHookOptions_NoSz;
typedef boost::intrusive::set<Melem_NoSz, MemberHookOptions_NoSz, boost::intrusive::constant_time_size<false> > MContainer_NoSz;
MContainer_NoSz container;
Melem_NoSz melem1(1);
Melem_NoSz melem2(2);
container.insert(melem1);
container.insert(melem2);
MContainer_NoSz::iterator itr = container.begin();
MContainer_NoSz::const_iterator citr = container.begin();
container.clear();
}
void TestIntrusiveSet()
{
TestIntrusiveSet_BaseHook();
TestIntrusiveSet_MemberHook();
TestIntrusiveSet_BaseHook_NoSizeMember();
TestIntrusiveSet_MemberHook_NoSizeMember();
}
void TestMultiArray()
{
// Create a 3D array that is 3 x 4 x 2
typedef boost::multi_array<double, 3> array_type;
typedef array_type::index index;
array_type A(boost::extents[3][4][2]);
// Assign values to the elements
for (index i = 0; i != 3; ++i)
for (index j = 0; j != 4; ++j)
for (index k = 0; k != 2; ++k)
A[i][j][k] = i * 100 + j * 10 + k;
typedef boost::multi_array<double, 2> array_type_2D;
array_type_2D myarray(boost::extents[3][4]);
typedef boost::multi_array_types::index_range range;
array_type_2D::array_view<2>::type myview =
myarray[boost::indices[range(1, 3)][range(0, 4, 2)]];
for (array_type_2D::index i = 0; i != 2; ++i)
for (array_type_2D::index j = 0; j != 2; ++j)
myview[i][j];
}
void TestMultiIndex()
{
using boost::multi_index_container;
using namespace boost::multi_index;
/* an employee record holds its ID, name and age */
struct employee
{
int id;
std::string name;
int age;
employee(int id_, std::string name_, int age_) :id(id_), name(name_), age(age_) {}
};
/* tags for accessing the corresponding indices of employee_set */
struct id {};
struct name {};
struct age {};
struct member {};
/* see Compiler specifics: Use of member_offset for info on
* BOOST_MULTI_INDEX_MEMBER
*/
/* Define a multi_index_container of employees with following indices:
* - a unique index sorted by employee::int,
* - a non-unique index sorted by employee::name,
* - a non-unique index sorted by employee::age.
*/
typedef multi_index_container<
employee,
indexed_by<
ordered_unique<
tag<id>, BOOST_MULTI_INDEX_MEMBER(employee, int, id)>,
ordered_non_unique<
tag<name>, BOOST_MULTI_INDEX_MEMBER(employee, std::string, name)>,
ordered_non_unique<
tag<age>, BOOST_MULTI_INDEX_MEMBER(employee, int, age)>
>
> employee_set;
employee_set es;
es.insert(employee(0, "Joe", 31));
es.insert(employee(1, "Robert", 27));
es.insert(employee(2, "John", 40));
es.insert(employee(2, "Aristotle", 2387));
es.insert(employee(3, "Albert", 20));
es.insert(employee(4, "John", 57));
}
void TestMultiprecision()
{
boost::multiprecision::cpp_int n("1522605");
boost::multiprecision::cpp_int n2("15226050279");
boost::multiprecision::cpp_int n3("152260502792253336053561837813263742971806");
boost::multiprecision::cpp_dec_float_50 nf("152260502792253336.053561837813263742971806");
boost::multiprecision::cpp_dec_float_100 nf100("1522605027922533.36053561837813263742971806");
}
void display(int depth, boost::property_tree::ptree& tree)
{
using boost::property_tree::ptree;
if (tree.empty())
return;
for (ptree::iterator pos = tree.begin(); pos != tree.end(); ++pos) {
//std::cout << pos->first << "\n";
display(depth + 1, pos->second);
}
}
void TestPropertyTree()
{
using boost::property_tree::ptree;
ptree pt;
std::ifstream input("test.xml");
read_xml(input, pt);
display(0, pt);
std::stringstream ss;
const char * json_string = R"(
{
"particles": [
{
"electron": {
"pos": [
0,
0,
0
],
"vel": [
0,
0,
0
]
},
"proton": {
"pos": [
-1,
0,
0
],
"vel": [
0,
-0.1,
-0.1
]
}
}
]
}
)";
ss << json_string;
ptree pt_json;
read_json(ss, pt_json);
display(0, pt_json);
}
void TestRational()
{
boost::rational<int> r(15, 3);
boost::rational<int> r2(5, 10);
}
void TestRegex()
{
boost::regex e("a(b+|((c)*))+d");
std::string text("abd");
boost::smatch what;
boost::regex_match(text, what, e, boost::match_extra);
}
void TestSmartPointers()
{
boost::scoped_ptr<Data> ptr(new Data());
ptr->Test();
boost::scoped_array<Data> ptrAr(new Data[10]());
ptrAr[0].Test();
boost::shared_ptr<Data> shPtr(new Data());
shPtr->Test();
boost::weak_ptr<Data> weakPtr(shPtr);
shPtr.reset();
boost::shared_ptr<Data> shPtrEx(new Data(), mallocDeleter);
shPtrEx->Test();
boost::shared_array<Data> shPtrAr(new Data[10]());
shPtrAr[0].Test();
}
void TestUblas()
{
using namespace boost::numeric::ublas;
vector<double> v(3);
mapped_vector<double> mv(3, 3);
mv[2] = 2.0;
mv[1] = 4.0;
compressed_vector<double> cv(3, 3);
cv[2] = 102.0;
cv[1] = 101.0;
cv[0] = 100.0;
coordinate_vector<double> rv(3, 3);
rv[2] = 102.0;
rv[1] = 101.0;
rv[0] = 100.0;
matrix<double> m(3, 4);
for (int i = 0; i < 3; i++)
for (int j = 0; j < 4; j++)
m(i, j) = i * 100 + j;
identity_matrix<double> im(3);
zero_matrix<double> zm(3, 3);
scalar_matrix<double> sm(3, 3);
}
void TestUnordered()
{
boost::unordered_map<std::string, int> um;
um["hfh"] = 73576;
um["jgfsjsf"] = 65;
boost::unordered_map<std::string, boost::unordered_set<int> > um2;
um2["dsfgal;sg"].insert(43534);
um2["dsfgal;sg"].insert(563);
um2["'/lreg"].insert(646);
um2["lfdhk"].insert(752);
boost::unordered_multimap<std::string, int> umm;
umm.insert(std::make_pair(std::string("sdhsh"), 73576));
umm.insert(std::make_pair(std::string("sdhsh"), 34578));
umm.insert(std::make_pair(std::string("jfsg"), 2));
auto p = *um.begin();
boost::unordered_set<int> us;
us.insert(5);
us.insert(6543765);
us.insert(468);
boost::unordered_multiset<int> uss;
uss.insert(63);
uss.insert(63);
uss.insert(8568);
}
void TestValueInitialized()
{
boost::value_initialized<int> vi_int;
boost::value_initialized<double> vi_double;
// vi_int == 0 and vi_double == 0.0
// change values
get(vi_int) = 42;
get(vi_double) = 12.34;
}
class visitor
: public boost::static_visitor < >
{
public:
template <typename T>
void operator()(T & i) const
{
i;
}
};
void TestVariantAnyOptional()
{
boost::variant<int, std::string, Data> var("gdsg");
var = 4;
boost::variant<int, std::string, Data, bool> var2(false);
var2 = 4;
typedef boost::make_recursive_variant <
int,
std::string,
std::vector < boost::recursive_variant_ >
> ::type int_tree_t;
std::vector< int_tree_t > subresult;
subresult.push_back("sadsad");
subresult.push_back(5);
int_tree_t vartt;
vartt = subresult;
std::vector < int_tree_t >& v = boost::get<std::vector < int_tree_t >>(vartt);
v[0] = 10;
std::vector< int_tree_t > result;
result.push_back(1);
result.push_back(subresult);
result.push_back("ahgsh");
// TODO: result[1] doesn't work ATM, cannot detect when boost::variant use boost::recursive_wrapper
boost::apply_visitor(visitor(), result[1]);
result.push_back(7);
// boost::mpl::vector not supported for boost >= 1.66
typedef boost::mpl::vector4<int, std::string, Data, bool> vec4_t;
boost::make_variant_over<vec4_t>::type variant_from_mpl_v4; // now contains int
variant_from_mpl_v4 = std::string("Hello word!");
typedef boost::mpl::vector<Data, std::string, int, bool, double> vec_t;
boost::make_variant_over<vec_t>::type variant_from_mpl_v; // now contains Data
variant_from_mpl_v = true;
variant_from_mpl_v = variant_from_mpl_v4;
// Testing variant representation on BIG MPL vectors
typedef boost::mpl::vector20 <
boost::array<char, 1>, boost::array<char, 2>, boost::array<char, 3>, boost::array<char, 4>, boost::array<char, 5>,
boost::array<char, 6>, boost::array<char, 7>, boost::array<char, 8>, boost::array<char, 9>, boost::array<char, 10>,
boost::array<char, 11>, boost::array<char, 12>, boost::array<char, 13>, boost::array<char, 14>, boost::array<char, 15>,
boost::array<char, 16>, boost::array<char, 17>, boost::array<char, 18>, boost::array<char, 19>, boost::array < char, 20 >
> vec20_t;
boost::make_variant_over<vec20_t>::type variant20;
variant20 = boost::array<char, 19>();
boost::any valany = 4;
valany = std::string("fdsfsd");
valany = true;
int val = 5;
boost::optional<int> opt = 4;
boost::optional<int&> optRef;
optRef = val;
const char* str = "very long string";
const wchar_t* wstr = L"very long string";
boost::string_view sv(str+5, 4);
boost::wstring_view wsv(wstr + 5, 4);
boost::string_ref rsv(str + 5, 4);
boost::wstring_ref rwsv(wstr + 5, 4);
}
void TestGsl()
{
std::array<int, 5> a{ 0, 1, 2, 3, 4};
gsl::span<int> a_sp(&a[2], &a[4]);
gsl::span<int, 2> a_ssp(&a[2], &a[4]);
std::string s("abcdefghi");
gsl::string_span<> str_sp(&s[3], 3);
gsl::string_span<3> str_sps(&s[3], 3);
}
int main(int argc, const char* argv[])
{
struct s {};
boost::filesystem::path p (argv[0]); // p reads clearer than argv[1] in the following code
boost::filesystem::file_status status;
if (boost::filesystem::exists(p)) // does p actually exist?
{
boost::filesystem::directory_iterator dit;
dit = boost::filesystem::directory_iterator(p.parent_path());
dit;
}
boost::tribool b(true);
b = false;
b = boost::indeterminate;
boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();
for ( long i = 0; i < 10000000; ++i )
std::sqrt( 123.456L ); // burn some time
boost::chrono::duration<double, boost::ratio<2,1>> sec = boost::chrono::system_clock::now() - start;
auto tupl = boost::make_tuple(1, "terterwt", true);
std::pair<int const, bool> p1;
std::pair<int const, s> p2;
std::pair<int const, const s> p3;
std::pair<int const, s*> p4;
std::pair<int const, boost::tribool> p5;
std::pair<int const, boost::filesystem::path> p6;
std::pair<int const, boost::unordered_set<int>> p7;
std::pair<int const, std::unique_ptr<s>> p8;
boost::uuids::string_generator gen;
boost::uuids::uuid u1 = gen("{92EC2A54-C1FA-42CB-B9F9-2602D507AD17}");
TestAtomic();
TestContainers();
TestGil();
TestGregorian();
TestInterprocess();
TestIntrusiveList();
TestIntrusiveSet();
TestLocalTime();
TestMultiArray();
TestMultiIndex();
TestMultiprecision();
TestPointerContainerLibrary();
TestPosixTime();
TestPropertyTree();
TestRational();
TestRegex();
TestSmartPointers();
TestUblas();
TestUnordered();
TestValueInitialized();
TestVariantAnyOptional();
TestGsl();
return EXIT_SUCCESS;
}
|
If $f$ and $g$ tend to $a$ and $b$, respectively, then $f^g$ tends to $a^b$. |
//This does CELL (~soma) stage of minimal GRU (gated recurrent unit) model.
//This requires each neuron to have 2 input time series, X and Xf,
//where X is the usual input and Xf the input for the forget-gate.
//Both X and Xf are the output of a linear IN stage (weights and baises).
//For dim=0: F[:,t] = sig(Xf[:,t] + Uf*Y[:,t-1])
// H[:,t] = F[:,t].*Y[:,t-1]
// Y[:,t] = H[:,t] + (1-F[:,t]).*tanh(X[:,t] + U*H[:,t])
//
//For dim=1: F[t,:] = sig(Xf[t,:] + Y[t-1,:]*Uf)
// H[t,:] = F[t,:].*Y[t-1,:]
// Y[t,:] = H[t,:] + (1-F[t,:]).*tanh(X[t,:] + H[t,:]*U)
//
//where sig is the logistic (sigmoid) nonlinearity = 1/(1+exp(-x)),
//F is the forget gate signal, H is an intermediate vector,
//U and Uf are NxN update matrices, and Y is the output.
//Note that, the neurons of a layer are independent only if U and Uf are diagonal matrices.
//This is only really a CELL (~soma) stage in that case.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <cblas.h>
#ifdef __cplusplus
namespace codee {
extern "C" {
#endif
int gru_min2_s (float *Y, const float *X, const float *Xf, const float *U, const float *Uf, const size_t N, const size_t T, const char iscolmajor, const size_t dim);
int gru_min2_d (double *Y, const double *X, const double *Xf, const double *U, const double *Uf, const size_t N, const size_t T, const char iscolmajor, const size_t dim);
int gru_min2_inplace_s (float *X, const float *Xf, const float *U, const float *Uf, const size_t N, const size_t T, const char iscolmajor, const size_t dim);
int gru_min2_inplace_d (double *X, const double *Xf, const double *U, const double *Uf, const size_t N, const size_t T, const char iscolmajor, const size_t dim);
int gru_min2_s (float *Y, const float *X, const float *Xf, const float *U, const float *Uf, const size_t N, const size_t T, const char iscolmajor, const size_t dim)
{
const float o = 1.0f;
size_t nT, tN;
float *F, *H;
if (!(F=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,"error in gru_min2_s: problem with malloc. "); perror("malloc"); return 1; }
if (!(H=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,"error in gru_min2_s: problem with malloc. "); perror("malloc"); return 1; }
if (N==1u)
{
F[0] = 1.0f / (1.0f+expf(-Xf[0]));
Y[0] = (1.0f-F[0]) * tanhf(X[0]);
for (size_t t=1; t<T; ++t)
{
F[0] = 1.0f / (1.0f+expf(-Xf[t]-Uf[0]*Y[t-1]));
H[0] = F[0] * Y[t-1];
Y[t] = H[0] + (1.0f-F[0])*tanhf(X[t]+U[0]*H[0]);
}
}
else if (dim==0u)
{
if (iscolmajor)
{
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-Xf[n]));
Y[n] = (1.0f-F[n]) * tanhf(X[n]);
}
for (size_t t=1; t<T; ++t)
{
tN = t*N;
cblas_scopy((int)N,&Xf[tN],1,F,1);
cblas_sgemv(CblasColMajor,CblasNoTrans,(int)N,(int)N,o,Uf,(int)N,&Y[tN-N],1,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-F[n]));
H[n] = F[n] * Y[tN-N+n];
}
cblas_scopy((int)N,&X[tN],1,&Y[tN],1);
cblas_sgemv(CblasColMajor,CblasNoTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&Y[tN],1);
for (size_t n=0u; n<N; ++n)
{
Y[tN+n] = H[n] + (1.0f-F[n])*tanhf(Y[tN+n]);
}
}
}
else
{
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
F[n] = 1.0f / (1.0f+expf(-Xf[nT]));
Y[nT] = (1.0f-F[n]) * tanhf(X[nT]);
}
for (size_t t=1; t<T; ++t)
{
cblas_scopy((int)N,&Xf[t],(int)T,F,1);
cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)N,(int)N,o,Uf,(int)N,&Y[t-1],(int)T,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-F[n]));
H[n] = F[n] * Y[t-1+n*T];
}
cblas_scopy((int)N,&X[t],(int)T,&Y[t],(int)T);
cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&Y[t],(int)T);
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
Y[t+nT] = H[n] + (1.0f-F[n])*tanhf(Y[t+nT]);
}
}
}
}
else if (dim==1u)
{
if (iscolmajor)
{
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
F[n] = 1.0f / (1.0f+expf(-Xf[nT]));
Y[nT] = (1.0f-F[n]) * tanhf(X[nT]);
}
for (size_t t=1; t<T; ++t)
{
cblas_scopy((int)N,&Xf[t],(int)T,F,1);
cblas_sgemv(CblasColMajor,CblasTrans,(int)N,(int)N,o,Uf,(int)N,&Y[t-1],(int)T,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-F[n]));
H[n] = F[n] * Y[t-1+n*T];
}
cblas_scopy((int)N,&X[t],(int)T,&Y[t],(int)T);
cblas_sgemv(CblasColMajor,CblasTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&Y[t],(int)T);
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
Y[t+nT] = H[n] + (1.0f-F[n])*tanhf(Y[t+nT]);
}
}
}
else
{
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-Xf[n]));
Y[n] = (1.0f-F[n]) * tanhf(X[n]);
}
for (size_t t=1; t<T; ++t)
{
tN = t*N;
cblas_scopy((int)N,&Xf[tN],1,F,1);
cblas_sgemv(CblasRowMajor,CblasTrans,(int)N,(int)N,o,Uf,(int)N,&Y[tN-N],1,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-F[n]));
H[n] = F[n] * Y[tN-N+n];
}
cblas_scopy((int)N,&X[tN],1,&Y[tN],1);
cblas_sgemv(CblasRowMajor,CblasTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&Y[tN],1);
for (size_t n=0u; n<N; ++n)
{
Y[tN+n] = H[n] + (1.0f-F[n])*tanhf(Y[tN+n]);
}
}
}
}
else
{
fprintf(stderr,"error in gru_min2_s: dim must be 0 or 1.\n"); return 1;
}
return 0;
}
int gru_min2_d (double *Y, const double *X, const double *Xf, const double *U, const double *Uf, const size_t N, const size_t T, const char iscolmajor, const size_t dim)
{
const double o = 1.0;
size_t nT, tN;
double *F, *H;
if (!(F=(double *)malloc(N*sizeof(double)))) { fprintf(stderr,"error in gru_min2_d: problem with malloc. "); perror("malloc"); return 1; }
if (!(H=(double *)malloc(N*sizeof(double)))) { fprintf(stderr,"error in gru_min2_d: problem with malloc. "); perror("malloc"); return 1; }
if (N==1u)
{
F[0] = 1.0 / (1.0+exp(-X[0]));
Y[0] = (1.0-F[0]) * tanh(X[0]);
for (size_t t=1; t<T; ++t)
{
F[0] = 1.0 / (1.0+exp(-X[t]-Uf[0]*Y[t-1]));
H[0] = F[0] * Y[t-1];
Y[t] = H[0] + (1.0-F[0])*tanh(X[t]+U[0]*H[0]);
}
}
else if (dim==0u)
{
if (iscolmajor)
{
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-Xf[n]));
Y[n] = (1.0-F[n]) * tanh(X[n]);
}
for (size_t t=1; t<T; ++t)
{
tN = t*N;
cblas_dcopy((int)N,&Xf[tN],1,F,1);
cblas_dgemv(CblasColMajor,CblasNoTrans,(int)N,(int)N,o,Uf,(int)N,&Y[tN-N],1,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-F[n]));
H[n] = F[n] * Y[tN-N+n];
}
cblas_dcopy((int)N,&X[tN],1,&Y[tN],1);
cblas_dgemv(CblasColMajor,CblasNoTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&Y[tN],1);
for (size_t n=0u; n<N; ++n)
{
Y[tN+n] = H[n] + (1.0-F[n])*tanh(Y[tN+n]);
}
}
}
else
{
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
F[n] = 1.0 / (1.0+exp(-Xf[nT]));
Y[nT] = (1.0-F[n]) * tanh(X[nT]);
}
for (size_t t=1; t<T; ++t)
{
cblas_dcopy((int)N,&Xf[t],(int)T,F,1);
cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)N,(int)N,o,Uf,(int)N,&Y[t-1],(int)T,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-F[n]));
H[n] = F[n] * Y[t-1+n*T];
}
cblas_dcopy((int)N,&X[t],(int)T,&Y[t],(int)T);
cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&Y[t],(int)T);
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
Y[t+nT] = H[n] + (1.0-F[n])*tanh(Y[t+nT]);
}
}
}
}
else if (dim==1u)
{
if (iscolmajor)
{
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
F[n] = 1.0 / (1.0+exp(-Xf[nT]));
Y[nT] = (1.0-F[n]) * tanh(X[nT]);
}
for (size_t t=1; t<T; ++t)
{
cblas_dcopy((int)N,&Xf[t],(int)T,F,1);
cblas_dgemv(CblasColMajor,CblasTrans,(int)N,(int)N,o,Uf,(int)N,&Y[t-1],(int)T,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-F[n]));
H[n] = F[n] * Y[t-1+n*T];
}
cblas_dcopy((int)N,&X[t],(int)T,&Y[t],(int)T);
cblas_dgemv(CblasColMajor,CblasTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&Y[t],(int)T);
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
Y[t+nT] = H[n] + (1.0-F[n])*tanh(Y[t+nT]);
}
}
}
else
{
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-Xf[n]));
Y[n] = (1.0-F[n]) * tanh(X[n]);
}
for (size_t t=1; t<T; ++t)
{
tN = t*N;
cblas_dcopy((int)N,&Xf[tN],1,F,1);
cblas_dgemv(CblasRowMajor,CblasTrans,(int)N,(int)N,o,Uf,(int)N,&Y[tN-N],1,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-F[n]));
H[n] = F[n] * Y[tN-N+n];
}
cblas_dcopy((int)N,&X[tN],1,&Y[tN],1);
cblas_dgemv(CblasRowMajor,CblasTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&Y[tN],1);
for (size_t n=0u; n<N; ++n)
{
Y[tN+n] = H[n] + (1.0-F[n])*tanh(Y[tN+n]);
}
}
}
}
else
{
fprintf(stderr,"error in gru_min2_d: dim must be 0 or 1.\n"); return 1;
}
return 0;
}
int gru_min2_inplace_s (float *X, const float *Xf, const float *U, const float *Uf, const size_t N, const size_t T, const char iscolmajor, const size_t dim)
{
const float o = 1.0f;
size_t nT, tN;
float *F, *H;
if (!(F=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,"error in gru_min2_inplace_s: problem with malloc. "); perror("malloc"); return 1; }
if (!(H=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,"error in gru_min2_inplace_s: problem with malloc. "); perror("malloc"); return 1; }
if (N==1u)
{
F[0] = 1.0f / (1.0f+expf(-X[0]));
X[0] = (1.0f-F[0]) * tanhf(X[0]);
for (size_t t=1; t<T; ++t)
{
F[0] = 1.0f / (1.0f+expf(-X[t]-Uf[0]*X[t-1]));
H[0] = F[0]*X[t-1];
X[t] = H[0] + (1.0f-F[0])*tanhf(X[t]+U[0]*H[0]);
}
}
else if (dim==0u)
{
if (iscolmajor)
{
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-Xf[n]));
X[n] = (1.0f-F[n]) * tanhf(X[n]);
}
for (size_t t=1; t<T; ++t)
{
tN = t*N;
cblas_scopy((int)N,&Xf[tN],1,F,1);
cblas_sgemv(CblasColMajor,CblasNoTrans,(int)N,(int)N,o,Uf,(int)N,&X[tN-N],1,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-F[n]));
H[n] = F[n] * X[tN-N+n];
}
cblas_sgemv(CblasColMajor,CblasNoTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&X[tN],1);
for (size_t n=0u; n<N; ++n)
{
X[tN+n] = H[n] + (1.0f-F[n])*tanhf(X[tN+n]);
}
}
}
else
{
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
F[n] = 1.0f / (1.0f+expf(-Xf[nT]));
X[nT] = (1.0f-F[n]) * tanhf(X[nT]);
}
for (size_t t=1; t<T; ++t)
{
cblas_scopy((int)N,&Xf[t],(int)T,F,1);
cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)N,(int)N,o,Uf,(int)N,&X[t-1],(int)T,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-F[n]));
H[n] = F[n] * X[t-1+n*T];
}
cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&X[t],(int)T);
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
X[t+nT] = H[n] + (1.0f-F[n])*tanhf(X[t+nT]);
}
}
}
}
else if (dim==1u)
{
if (iscolmajor)
{
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
F[n] = 1.0f / (1.0f+expf(-Xf[nT]));
X[nT] = (1.0f-F[n]) * tanhf(X[nT]);
}
for (size_t t=1; t<T; ++t)
{
cblas_scopy((int)N,&Xf[t],(int)T,F,1);
cblas_sgemv(CblasColMajor,CblasTrans,(int)N,(int)N,o,Uf,(int)N,&X[t-1],(int)T,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-F[n]));
H[n] = F[n] * X[t-1+n*T];
}
cblas_sgemv(CblasColMajor,CblasTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&X[t],(int)T);
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
X[t+nT] = H[n] + (1.0f-F[n])*tanhf(X[t+nT]);
}
}
}
else
{
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-Xf[n]));
X[n] = (1.0f-F[n]) * tanhf(X[n]);
}
for (size_t t=1; t<T; ++t)
{
tN = t*N;
cblas_scopy((int)N,&Xf[tN],1,F,1);
cblas_sgemv(CblasRowMajor,CblasTrans,(int)N,(int)N,o,Uf,(int)N,&X[tN-N],1,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0f / (1.0f+expf(-F[n]));
H[n] = F[n] * X[tN-N+n];
}
cblas_sgemv(CblasRowMajor,CblasTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&X[tN],1);
for (size_t n=0u; n<N; ++n)
{
X[tN+n] = H[n] + (1.0f-F[n])*tanhf(X[tN+n]);
}
}
}
}
else
{
fprintf(stderr,"error in gru_min2_inplace_s: dim must be 0 or 1.\n"); return 1;
}
return 0;
}
int gru_min2_inplace_d (double *X, const double *Xf, const double *U, const double *Uf, const size_t N, const size_t T, const char iscolmajor, const size_t dim)
{
const double o = 1.0;
size_t nT, tN;
double *F, *H;
if (!(F=(double *)malloc(N*sizeof(double)))) { fprintf(stderr,"error in gru_min2_inplace_d: problem with malloc. "); perror("malloc"); return 1; }
if (!(H=(double *)malloc(N*sizeof(double)))) { fprintf(stderr,"error in gru_min2_inplace_d: problem with malloc. "); perror("malloc"); return 1; }
if (N==1u)
{
F[0] = 1.0 / (1.0+exp(-X[0]));
X[0] = (1.0-F[0]) * tanh(X[0]);
for (size_t t=1; t<T; ++t)
{
F[0] = 1.0 / (1.0+exp(-X[t]-Uf[0]*X[t-1]));
H[0] = F[0]*X[t-1];
X[t] = H[0] + (1.0-F[0])*tanh(X[t]+U[0]*H[0]);
}
}
else if (dim==0u)
{
if (iscolmajor)
{
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-Xf[n]));
X[n] = (1.0-F[n]) * tanh(X[n]);
}
for (size_t t=1; t<T; ++t)
{
tN = t*N;
cblas_dcopy((int)N,&Xf[tN],1,F,1);
cblas_dgemv(CblasColMajor,CblasNoTrans,(int)N,(int)N,o,Uf,(int)N,&X[tN-N],1,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-F[n]));
H[n] = F[n] * X[tN-N+n];
}
cblas_dgemv(CblasColMajor,CblasNoTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&X[tN],1);
for (size_t n=0u; n<N; ++n)
{
X[tN+n] = H[n] + (1.0-F[n])*tanh(X[tN+n]);
}
}
}
else
{
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
F[n] = 1.0 / (1.0+exp(-Xf[nT]));
X[nT] = (1.0-F[n]) * tanh(X[nT]);
}
for (size_t t=1; t<T; ++t)
{
cblas_dcopy((int)N,&Xf[t],(int)T,F,1);
cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)N,(int)N,o,Uf,(int)N,&X[t-1],(int)T,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-F[n]));
H[n] = F[n] * X[t-1+n*T];
}
cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&X[t],(int)T);
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
X[t+nT] = H[n] + (1.0-F[n])*tanh(X[t+nT]);
}
}
}
}
else if (dim==1u)
{
if (iscolmajor)
{
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
F[n] = 1.0 / (1.0+exp(-Xf[nT]));
X[nT] = (1.0-F[n]) * tanh(X[nT]);
}
for (size_t t=1; t<T; ++t)
{
cblas_dcopy((int)N,&Xf[t],(int)T,F,1);
cblas_dgemv(CblasColMajor,CblasTrans,(int)N,(int)N,o,Uf,(int)N,&X[t-1],(int)T,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-F[n]));
H[n] = F[n] * X[t-1+n*T];
}
cblas_dgemv(CblasColMajor,CblasTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&X[t],(int)T);
for (size_t n=0u; n<N; ++n)
{
nT = n*T;
X[t+nT] = H[n] + (1.0-F[n])*tanh(X[t+nT]);
}
}
}
else
{
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-Xf[n]));
X[n] = (1.0-F[n]) * tanh(X[n]);
}
for (size_t t=1; t<T; ++t)
{
tN = t*N;
cblas_dcopy((int)N,&Xf[tN],1,F,1);
cblas_dgemv(CblasRowMajor,CblasTrans,(int)N,(int)N,o,Uf,(int)N,&X[tN-N],1,o,F,1);
for (size_t n=0u; n<N; ++n)
{
F[n] = 1.0 / (1.0+exp(-F[n]));
H[n] = F[n] * X[tN-N+n];
}
cblas_dgemv(CblasRowMajor,CblasTrans,(int)N,(int)N,o,U,(int)N,H,1,o,&X[tN],1);
for (size_t n=0u; n<N; ++n)
{
X[tN+n] = H[n] + (1.0-F[n])*tanh(X[tN+n]);
}
}
}
}
else
{
fprintf(stderr,"error in gru_min2_inplace_d: dim must be 0 or 1.\n"); return 1;
}
return 0;
}
#ifdef __cplusplus
}
}
#endif
|
function smallpot = marginalize_pot(bigpot, keep, maximize, useC)
% MARGINALIZE_POT Marginalize a cpot onto a smaller domain.
% smallpot = marginalize_pot(bigpot, keep, maximize, useC)
%
% The maximize argument is ignored - maxing out a Gaussian is the same as summing it out,
% since the mode and mean are equal.
% The useC argument is ignored.
node_sizes = sparse(1, max(bigpot.domain));
node_sizes(bigpot.domain) = bigpot.sizes;
sum_over = mysetdiff(bigpot.domain, keep);
if sum(node_sizes(sum_over))==0 % isempty(sum_over)
%smallpot = bigpot;
smallpot = cpot(keep, node_sizes(keep), bigpot.g, bigpot.h, bigpot.K);
else
[h1, h2, K11, K12, K21, K22] = partition_matrix_vec(bigpot.h, bigpot.K, sum_over, keep, node_sizes);
n = length(h1);
K11inv = inv(K11);
g = bigpot.g + 0.5*(n*log(2*pi) - log(det(K11)) + h1'*K11inv*h1);
if length(h2) > 0 % ~isempty(keep) % we are are actually keeping something
A = K21*K11inv;
h = h2 - A*h1;
K = K22 - A*K12;
else
h = [];
K = [];
end
smallpot = cpot(keep, node_sizes(keep), g, h, K);
end
|
Address(Stanford Place) is a residential Culdesacs culdesac in Central Davis.
Intersecting Streets
Sycamore Lane and across the intersection Stanford Drive
|
% book : Signals and Systems Laboratory with MATLAB
% authors : Alex Palamides & Anastasia Veloni
%
%
%
% Transformations of the time variable - discrete time signals
%upsampling-downsampling
x=[1,2,3,4,5,6]
a=2;
xds=downsample(x,a)
xds=x(1:a:end)
a=1/2;
xups=upsample(x,1/a)
xups=zeros(1,1/a*length(x))
xups(1:1/a:end)=x
%all transformations
n=-20:20;
p=( (n>=-10)&(n<=10));
x=(0.9.^n).*p;
stem(n,x);
legend('x[n]') ;
figure
stem(n+10,x)
legend('x[n-10]')
figure
stem(n-10,x)
legend('x[n+10]')
figure
a=2;
xd=downsample(x,a)
nd=-10:10;
stem(nd,xd);
legend('x[2n]')
figure
a=1/3
xup=upsample(x,1/a)
nup=-61:61
stem(nup,xup)
legend('x[(1/3) n]')
figure
stem(-n,x)
legend('x[-n]')
figure
n=-2:4;
n1=-fliplr(n)
x=0.9.^n
x1=fliplr(x)
subplot(121);
stem(n,x);
title('x[n]=0.9^n');
subplot(122);
stem(n1,x1);
title('x[-n]');
|
Two continuous maps $f, g: X \to Y$ are homotopic if and only if $g, f: X \to Y$ are homotopic. |
function funhan = piecewise(varargin)
%PIECEWISE Piecewise-defined functions.
%
% F = PIECEWISE(COND1,DEFN1,...CONDn,DEFNn,DEFAULT) returns a callable
% function F that applies different definitions according to supplied
% conditions. For a given X, F(X) will test COND1 and apply DEFN1 if true,
% etc. If all conditions fail, then DEFAULT is applied. For any particular
% input, the first condition to match is the only one applied.
%
% Each condition should be either a:
% * function handle evaluating to logical values, or
% * vector [a b] representing membership in the half-open interval [a,b).
% Each definition should be either a:
% * function handle, or
% * scalar value.
% The DEFAULT definition is optional; if omitted, it will be set to NaN.
%
% All function definitions can accept multiple input variables, but they
% all must accept the same number as in the call to F. They also should
% all be vectorized, returning results the same size and shape as their
% inputs. Complex inputs will work if the definitions are set up
% accordingly; in that case, intervals will be tested using only Re parts.
%
% The special syntax F() displays all the conditions and definitions for F.
%
% Examples:
% f = piecewise([-1 1],@(x) 1+cos(pi*x),0); % a "cosine bell"
% ezplot(f,[-2 2])
% g = piecewise(@(x) sin(x)<0.5,@sin,@(x) 1-sin(x));
% ezplot(g,[-2*pi 2*pi])
% h = piecewise(@(x,y) (x<0)|(y<0),@(x,y) sin(x-y)); % defined on L
% ezsurf(h,[-1 1])
% chi = piecewise(@(x,y,z) x.^2+y.^2+z.^2<1,1,0); % characteristic func
% [ triplequad(chi,-1,1,-1,1,-1,1), 4/3*pi ]
% ans =
% 4.1888 4.1888
%
% See also FUNCTION_HANDLE.
% Copyright (c) 2007 by Toby Driscoll.
% Version 1, 6 Aug 2007.
% If an even number of inputs was given, no default value exists.
if rem(nargin,2)==0
default = NaN;
else
default = varargin{end};
end
% Number of condition/definition pairs.
numdefs = floor(nargin/2);
condn = varargin(1:2:2*numdefs);
defn = varargin(2:2:2*numdefs);
funhan = @piecewisefun; % this is the return value
% This is the defintion of the returned function.
function f = piecewisefun(varargin)
% Special syntax to display the function.
if nargin==0
fprintf('\nPiecewise function with conditions/definitions:\n')
for k = 1:numdefs
fprintf(' If %s : %s\n',funcornum2str(condn{k}),funcornum2str(defn{k}))
end
fprintf(' Otherwise : %s\n\n',funcornum2str(default))
return
end
% Normal call
f = zeros(size(varargin{1}));
mask = false(size(f));
for k = 1:numdefs
% Determine the values satistfying condition k.
if isa(condn{k},'function_handle')
newpts = logical( condn{k}(varargin{:}) );
else
newpts = (varargin{1}>=condn{k}(1)) & (varargin{1}<condn{k}(2));
end
newpts = newpts & (~mask);
% Evaluate definition k
if isa(defn{k},'function_handle')
% Tricky part: Extract subset of points from each variable.
sref.type = '()';
sref.subs = {newpts};
extract = @(x) subsref(x,sref);
x = cellfun(extract,varargin,'uniformoutput',false);
f(newpts) = defn{k}(x{:});
else
f(newpts) = defn{k}; % scalar expansion
end
mask = mask | newpts;
end
% Default case
if isa(default,'function_handle')
sref.subs = {~mask};
extract = @(x) subsref(x,sref);
x = cellfun(extract,varargin,'uniformoutput',false);
f(~mask) = default(x{:});
else
f(~mask) = default; % scalar expansion
end
end
% This subfunction converts a function or scalar to its native char form,
% and a 2-vector into an interval notation.
function s = funcornum2str(f)
if isa(f,'function_handle')
s = char(f);
elseif numel(f)==1
s = num2str(f);
else
s = [ 'in [' num2str(f(1)) ',' num2str(f(2)) ')' ];
end
end
end |
{-# OPTIONS --cubical #-}
module leibniz where
open import Cubical.Data.Equality
open import Cubical.Foundations.Function using (_β_)
module Martin-LΓΆf {β} {A : Set β} where
reflexiveβ‘ : {a : A} β a β‘p a
reflexiveβ‘ = reflp
symmetricβ‘ : {a b : A} β a β‘p b β b β‘p a
symmetricβ‘ reflp = reflp
transitiveβ‘ : {a b c : A} β a β‘p b β b β‘p c β a β‘p c
transitiveβ‘ reflp reflp = reflp
open Martin-LΓΆf public
ext : β {β ββ²} {A : Set β} {B : A β Set ββ²} {f g : (a : A) β B a} β
(β (a : A) β f a β‘p g a) β f β‘p g
ext p = ctop (funExt (ptoc β p))
module Leibniz {A : Set} where
_β_ : (a b : A) β Setβ
a β b = (P : A β Set) β P a β P b
reflexiveβ : {a : A} β a β a
reflexiveβ P Pa = Pa
transitiveβ : {a b c : A} β a β b β b β c β a β c
transitiveβ aβb bβc P Pa = bβc P (aβb P Pa)
symmetricβ : {a b : A} β a β b β b β a
symmetricβ {a} {b} aβb P = Qb
where
Q : A β Set
Q c = P c β P a
Qa : Q a
Qa = reflexiveβ P
Qb : Q b
Qb = aβb Q Qa
open Leibniz
T : Set β Setβ
T A = β (X : Set) β (A β X) β X
module WarmUp (A : Set) where
postulate
paramT : (t : T A) β (X Xβ² : Set) (R : X β Xβ² β Set) β
(k : A β X) (kβ² : A β Xβ²) (kR : (a : A) β R (k a) (kβ² a)) β
R (t X k) (t Xβ² kβ²)
i : A β T A
i a X k = k a
id : A β A
id a = a
j : T A β A
j t = t A id
ji : (a : A) β (j (i a) β‘p a)
ji a = reflp
ijβββ : (t : T A) (X : Set) (k : A β X) β (i (j t) X k β‘p t X k)
ijβββ t X k = paramT t A X R id k (Ξ» a β reflp)
where
R : A β X β Set
R a x = k a β‘p x
ij : (t : T A) β (i (j t) β‘p t)
ij t = ext (Ξ» X β ext (Ξ» k β ijβββ t X k))
module MainResult (A : Set) where
postulate
paramβ : {a b : A} (aβb : a β b) β
(P Pβ² : A β Set) β (R : (c : A) β P c β Pβ² c β Set) β
(Pa : P a) (Pβ²a : Pβ² a) β R a Pa Pβ²a β
R b (aβb P Pa) (aβb Pβ² Pβ²a)
i : {a b : A} (aβ‘b : a β‘p b) β a β b
i reflp P Pa = Pa
j : {a b : A} β a β b β a β‘p b
j {a} {b} aβb = Qb
where
Q : A β Set
Q c = a β‘p c
Qa : Q a
Qa = reflexiveβ‘
Qb : Q b
Qb = aβb Q Qa
ji : {a b : A} (aβ‘b : a β‘p b) β j (i aβ‘b) β‘p aβ‘b
ji reflp = reflp
ijβββ : {a b : A} (aβb : a β b) β
(P : A β Set) (Pa : P a) β i (j aβb) P Pa β‘p aβb P Pa
ijβββ {a} aβb P Pa = paramβ aβb Q P R reflp Pa reflp
where
Q : A β Set
Q c = a β‘p c
R : (c : A) (Qc : Q c) (Pc : P c) β Set
R c Qc Pc = i Qc P Pa β‘p Pc
ij : {a b : A} (aβb : a β b) β i (j aβb) β‘p aβb
ij aβb = ext (Ξ» P β ext (ijβββ aβb P))
|
Formal statement is: lemma Zfun_le: "Zfun g F \<Longrightarrow> \<forall>x. norm (f x) \<le> norm (g x) \<Longrightarrow> Zfun f F" Informal statement is: If $f$ is a Z-function and $g$ is a Z-function such that $|f(x)| \leq |g(x)|$ for all $x$, then $f$ is a Z-function. |
!>
!! @file m_cbc.f90
!! @brief Contains module m_cbc
!> @brief The module features a large database of characteristic boundary
!! conditions (CBC) for the Euler system of equations. This system
!! is augmented by the appropriate advection equations utilized to
!! capture the material interfaces. The closure is achieved by the
!! stiffened equation of state and mixture relations. At this time,
!! the following CBC are available:
!! 1) Slip Wall
!! 2) Nonreflecting Subsonic Buffer
!! 3) Nonreflecting Subsonic Inflow
!! 4) Nonreflecting Subsonic Outflow
!! 5) Force-Free Subsonic Outflow
!! 6) Constant Pressure Subsonic Outflow
!! 7) Supersonic Inflow
!! 8) Supersonic Outflow
!! Please refer to Thompson (1987, 1990) for detailed descriptions.
MODULE m_cbc
! Dependencies =============================================================
USE m_derived_types !< Definitions of the derived types
USE m_global_parameters !< Definitions of the global parameters
USE m_variables_conversion !< State variables type conversion procedures
! ==========================================================================
IMPLICIT NONE
PRIVATE; PUBLIC :: s_initialize_cbc_module, s_cbc, s_finalize_cbc_module
ABSTRACT INTERFACE ! =======================================================
!> Abstract interface to the procedures that are utilized to calculate
!! the L variables. For additional information refer to the following:
!! 1) s_compute_slip_wall_L
!! 2) s_compute_nonreflecting_subsonic_buffer_L
!! 3) s_compute_nonreflecting_subsonic_inflow_L
!! 4) s_compute_nonreflecting_subsonic_outflow_L
!! 5) s_compute_force_free_subsonic_outflow_L
!! 6) s_compute_constant_pressure_subsonic_outflow_L
!! 7) s_compute_supersonic_inflow_L
!! 8) s_compute_supersonic_outflow_L
!! @param dflt_int Default null integer
SUBROUTINE s_compute_abstract_L(dflt_int)
INTEGER, INTENT(IN) :: dflt_int
END SUBROUTINE s_compute_abstract_L
END INTERFACE ! ============================================================
TYPE(scalar_field), ALLOCATABLE, DIMENSION(:) :: q_prim_rs_vf !<
!! The cell-average primitive variables. They are obtained by reshaping (RS)
!! q_prim_vf in the coordinate direction normal to the domain boundary along
!! which the CBC is applied.
TYPE(scalar_field), ALLOCATABLE, DIMENSION(:) :: F_rs_vf, F_src_rs_vf !<
!! Cell-average fluxes (src - source). These are directly determined from the
!! cell-average primitive variables, q_prims_rs_vf, and not a Riemann solver.
TYPE(scalar_field), ALLOCATABLE, DIMENSION(:) :: flux_rs_vf, flux_src_rs_vf !<
!! The cell-boundary-average of the fluxes. They are initially determined by
!! reshaping flux_vf and flux_src_vf in a coordinate direction normal to the
!! domain boundary along which CBC is applied. flux_rs_vf and flux_src_rs_vf
!! are subsequently modified based on the selected CBC.
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: alpha_rho !< Cell averaged partial densiy
REAL(KIND(0d0)) :: rho !< Cell averaged density
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: vel !< Cell averaged velocity
REAL(KIND(0d0)) :: pres !< Cell averaged pressure
REAL(KIND(0d0)) :: E !< Cell averaged energy
REAL(KIND(0d0)) :: H !< Cell averaged enthalpy
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: adv !< Cell averaged advected variables
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: mf !< Cell averaged mass fraction
REAL(KIND(0d0)) :: gamma !< Cell averaged specific heat ratio
REAL(KIND(0d0)) :: pi_inf !< Cell averaged liquid stiffness
REAL(KIND(0d0)) :: c !< Cell averaged speed of sound
REAL(KIND(0d0)), DIMENSION(2) :: Re !< Cell averaged Reynolds numbers
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:,:) :: We !< Cell averaged Weber numbers
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: dalpha_rho_ds !< Spatial derivatives in s-dir of partial density
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: dvel_ds !< Spatial derivatives in s-dir of velocity
REAL(KIND(0d0)) :: dpres_ds !< Spatial derivatives in s-dir of pressure
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: dadv_ds !< Spatial derivatives in s-dir of advection variables
!! Note that these are only obtained in those cells on the domain boundary along which the
!! CBC is applied by employing finite differences (FD) on the cell-average primitive variables, q_prim_rs_vf.
REAL(KIND(0d0)), DIMENSION(3) :: lambda !< Eigenvalues (see Thompson 1987,1990)
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: L !< L matrix (see Thompson 1987,1990)
REAL(KIND(0d0)), ALLOCATABLE, DIMENSION(:) :: ds !< Cell-width distribution in the s-direction
! CBC Coefficients =========================================================
REAL(KIND(0d0)), TARGET, ALLOCATABLE, DIMENSION(:,:) :: fd_coef_x !< Finite diff. coefficients x-dir
REAL(KIND(0d0)), TARGET, ALLOCATABLE, DIMENSION(:,:) :: fd_coef_y !< Finite diff. coefficients y-dir
REAL(KIND(0d0)), TARGET, ALLOCATABLE, DIMENSION(:,:) :: fd_coef_z !< Finite diff. coefficients z-dir
!! The first dimension identifies the location of a coefficient in the FD
!! formula, while the last dimension denotes the location of the CBC.
REAL(KIND(0d0)), POINTER, DIMENSION(:,:) :: fd_coef => NULL()
REAL(KIND(0d0)), TARGET, ALLOCATABLE, DIMENSION(:,:,:) :: pi_coef_x !< Polynominal interpolant coefficients in x-dir
REAL(KIND(0d0)), TARGET, ALLOCATABLE, DIMENSION(:,:,:) :: pi_coef_y !< Polynominal interpolant coefficients in y-dir
REAL(KIND(0d0)), TARGET, ALLOCATABLE, DIMENSION(:,:,:) :: pi_coef_z !< Polynominal interpolant coefficients in z-dir
!! The first dimension of the array identifies the polynomial, the
!! second dimension identifies the position of its coefficients and the last
!! dimension denotes the location of the CBC.
REAL(KIND(0d0)), POINTER, DIMENSION(:,:,:) :: pi_coef => NULL()
! ==========================================================================
PROCEDURE(s_compute_abstract_L), POINTER :: s_compute_L => NULL() !<
!! Pointer to procedure used to calculate L variables, based on choice of CBC
TYPE(bounds_info) :: is1,is2,is3 !< Indical bounds in the s1-, s2- and s3-directions
CONTAINS
!> The computation of parameters, the allocation of memory,
!! the association of pointers and/or the execution of any
!! other procedures that are necessary to setup the module.
SUBROUTINE s_initialize_cbc_module() ! ---------------------------------
IF( ALL((/bc_x%beg,bc_x%end/) > -5) &
.AND. &
(n > 0 .AND. ALL((/bc_y%beg,bc_y%end/) > -5)) &
.AND. &
(p > 0 .AND. ALL((/bc_z%beg,bc_z%end/) > -5)) ) RETURN
! Allocating the cell-average primitive variables
ALLOCATE(q_prim_rs_vf(1:sys_size))
! Allocating the cell-average and cell-boundary-average fluxes
ALLOCATE( F_rs_vf(1:sys_size), F_src_rs_vf(1:sys_size))
ALLOCATE(flux_rs_vf(1:sys_size), flux_src_rs_vf(1:sys_size))
! Allocating the cell-average partial densities, the velocity, the
! advected variables, the mass fractions, as well as Weber numbers
ALLOCATE(alpha_rho(1: cont_idx%end ))
ALLOCATE( vel(1: num_dims ))
ALLOCATE( adv(1:adv_idx%end-E_idx))
ALLOCATE( mf(1: cont_idx%end ))
ALLOCATE(We(1:num_fluids,1:num_fluids))
! Allocating the first-order spatial derivatives in the s-direction
! of the partial densities, the velocity and the advected variables
ALLOCATE(dalpha_rho_ds(1: cont_idx%end ))
ALLOCATE( dvel_ds(1: num_dims ))
ALLOCATE( dadv_ds(1:adv_idx%end-E_idx))
! Allocating L, see Thompson (1987, 1990)
ALLOCATE(L(1:adv_idx%end))
! Allocating the cell-width distribution in the s-direction
ALLOCATE(ds(0:buff_size))
! Allocating/Computing CBC Coefficients in x-direction =============
IF(ALL((/bc_x%beg,bc_x%end/) <= -5)) THEN
ALLOCATE(fd_coef_x(0:buff_size,-1: 1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_x(0:weno_polyn-1,0:weno_order-3,-1: 1))
END IF
CALL s_compute_cbc_coefficients(1,-1)
CALL s_compute_cbc_coefficients(1, 1)
ELSEIF(bc_x%beg <= -5) THEN
ALLOCATE(fd_coef_x(0:buff_size,-1:-1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_x(0:weno_polyn-1,0:weno_order-3,-1:-1))
END IF
CALL s_compute_cbc_coefficients(1,-1)
ELSEIF(bc_x%end <= -5) THEN
ALLOCATE(fd_coef_x(0:buff_size, 1: 1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_x(0:weno_polyn-1,0:weno_order-3, 1: 1))
END IF
CALL s_compute_cbc_coefficients(1, 1)
END IF
! ==================================================================
! Allocating/Computing CBC Coefficients in y-direction =============
IF(n > 0) THEN
IF(ALL((/bc_y%beg,bc_y%end/) <= -5)) THEN
ALLOCATE(fd_coef_y(0:buff_size,-1: 1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_y(0:weno_polyn-1,0:weno_order-3,-1: 1))
END IF
CALL s_compute_cbc_coefficients(2,-1)
CALL s_compute_cbc_coefficients(2, 1)
ELSEIF(bc_y%beg <= -5) THEN
ALLOCATE(fd_coef_y(0:buff_size,-1:-1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_y(0:weno_polyn-1,0:weno_order-3,-1:-1))
END IF
CALL s_compute_cbc_coefficients(2,-1)
ELSEIF(bc_y%end <= -5) THEN
ALLOCATE(fd_coef_y(0:buff_size, 1: 1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_y(0:weno_polyn-1,0:weno_order-3, 1: 1))
END IF
CALL s_compute_cbc_coefficients(2, 1)
END IF
END IF
! ==================================================================
! Allocating/Computing CBC Coefficients in z-direction =============
IF(p > 0) THEN
IF(ALL((/bc_z%beg,bc_z%end/) <= -5)) THEN
ALLOCATE(fd_coef_z(0:buff_size,-1: 1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_z(0:weno_polyn-1,0:weno_order-3,-1: 1))
END IF
CALL s_compute_cbc_coefficients(3,-1)
CALL s_compute_cbc_coefficients(3, 1)
ELSEIF(bc_z%beg <= -5) THEN
ALLOCATE(fd_coef_z(0:buff_size,-1:-1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_z(0:weno_polyn-1,0:weno_order-3,-1:-1))
END IF
CALL s_compute_cbc_coefficients(3,-1)
ELSEIF(bc_z%end <= -5) THEN
ALLOCATE(fd_coef_z(0:buff_size, 1: 1))
IF(weno_order > 1) THEN
ALLOCATE(pi_coef_z(0:weno_polyn-1,0:weno_order-3, 1: 1))
END IF
CALL s_compute_cbc_coefficients(3, 1)
END IF
END IF
! ==================================================================
! Associating the procedural pointer to the appropriate subroutine
! that will be utilized in the conversion to the mixture variables
IF (model_eqns == 1) THEN ! Gamma/pi_inf model
s_convert_to_mixture_variables => &
s_convert_mixture_to_mixture_variables
ELSEIF (bubbles) THEN ! Volume fraction model
s_convert_to_mixture_variables => &
s_convert_species_to_mixture_variables_bubbles
ELSE ! Volume fraction model
s_convert_to_mixture_variables => &
s_convert_species_to_mixture_variables
END IF
END SUBROUTINE s_initialize_cbc_module ! -------------------------------
SUBROUTINE s_compute_cbc_coefficients(cbc_dir, cbc_loc) ! --------------
! Description: The purpose of this subroutine is to compute the grid
! dependent FD and PI coefficients, or CBC coefficients,
! provided the CBC coordinate direction and location.
! CBC coordinate direction and location
INTEGER, INTENT(IN) :: cbc_dir, cbc_loc
! Cell-boundary locations in the s-direction
REAL(KIND(0d0)), DIMENSION(0:buff_size+1) :: s_cb
! Generic loop iterator
INTEGER :: i
! Associating CBC coefficients pointers
CALL s_associate_cbc_coefficients_pointers(cbc_dir, cbc_loc)
! Determining the cell-boundary locations in the s-direction
s_cb(0) = 0d0
DO i = 0, buff_size
s_cb(i+1) = s_cb(i) + ds(i)
END DO
! Computing CBC1 Coefficients ======================================
IF(weno_order == 1) THEN
fd_coef(:,cbc_loc) = 0d0
fd_coef(0,cbc_loc) = -2d0/(ds(0)+ds(1))
fd_coef(1,cbc_loc) = -fd_coef(0,cbc_loc)
! ==================================================================
! Computing CBC2 Coefficients ======================================
ELSEIF(weno_order == 3) THEN
fd_coef(:,cbc_loc) = 0d0
fd_coef(0,cbc_loc) = -6d0/(3d0*ds(0)+2d0*ds(1)-ds(2))
fd_coef(1,cbc_loc) = -4d0*fd_coef(0,cbc_loc)/3d0
fd_coef(2,cbc_loc) = fd_coef(0,cbc_loc)/3d0
pi_coef(0,0,cbc_loc) = (s_cb(0)-s_cb(1))/(s_cb(0)-s_cb(2))
! ==================================================================
! Computing CBC4 Coefficients ======================================
ELSE
fd_coef(:,cbc_loc) = 0d0
fd_coef(0,cbc_loc) = -50d0/(25d0*ds(0)+2d0*ds(1) &
- 1d1*ds(2)+1d1*ds(3) &
- 3d0*ds(4) )
fd_coef(1,cbc_loc) = -48d0*fd_coef(0,cbc_loc)/25d0
fd_coef(2,cbc_loc) = 36d0*fd_coef(0,cbc_loc)/25d0
fd_coef(3,cbc_loc) = -16d0*fd_coef(0,cbc_loc)/25d0
fd_coef(4,cbc_loc) = 3d0*fd_coef(0,cbc_loc)/25d0
pi_coef(0,0,cbc_loc) = &
((s_cb(0)-s_cb(1))*(s_cb(1)-s_cb(2)) * &
(s_cb(1)-s_cb(3)))/((s_cb(1)-s_cb(4)) * &
(s_cb(4)-s_cb(0))*(s_cb(4)-s_cb(2)))
pi_coef(0,1,cbc_loc) = &
((s_cb(1)-s_cb(0))*(s_cb(1)-s_cb(2)) * &
((s_cb(1)-s_cb(3))*(s_cb(1)-s_cb(3)) - &
(s_cb(0)-s_cb(4))*((s_cb(3)-s_cb(1)) + &
(s_cb(4)-s_cb(1))))) / &
((s_cb(0)-s_cb(3))*(s_cb(1)-s_cb(3)) * &
(s_cb(0)-s_cb(4))*(s_cb(1)-s_cb(4)))
pi_coef(0,2,cbc_loc) = &
(s_cb(1)-s_cb(0))*((s_cb(1)-s_cb(2)) * &
(s_cb(1)-s_cb(3))+((s_cb(0)-s_cb(2)) + &
(s_cb(1)-s_cb(3)))*(s_cb(0)-s_cb(4))) / &
((s_cb(2)-s_cb(0))*(s_cb(0)-s_cb(3)) * &
(s_cb(0)-s_cb(4)))
pi_coef(1,0,cbc_loc) = &
((s_cb(0)-s_cb(2))*(s_cb(2)-s_cb(1)) * &
(s_cb(2)-s_cb(3)))/((s_cb(2)-s_cb(4)) * &
(s_cb(4)-s_cb(0))*(s_cb(4)-s_cb(1)))
pi_coef(1,1,cbc_loc) = &
((s_cb(0)-s_cb(2))*(s_cb(1)-s_cb(2)) * &
((s_cb(1)-s_cb(3))*(s_cb(2)-s_cb(3)) + &
(s_cb(0)-s_cb(4))*((s_cb(1)-s_cb(3)) + &
(s_cb(2)-s_cb(4))))) / &
((s_cb(0)-s_cb(3))*(s_cb(1)-s_cb(3)) * &
(s_cb(0)-s_cb(4))*(s_cb(1)-s_cb(4)))
pi_coef(1,2,cbc_loc) = &
((s_cb(1)-s_cb(2))*(s_cb(2)-s_cb(3)) * &
(s_cb(2)-s_cb(4)))/((s_cb(0)-s_cb(2)) * &
(s_cb(0)-s_cb(3))*(s_cb(0)-s_cb(4)))
END IF
! END: Computing CBC4 Coefficients =================================
! Nullifying CBC coefficients
NULLIFY(fd_coef, pi_coef)
END SUBROUTINE s_compute_cbc_coefficients ! ----------------------------
!! The goal of the procedure is to associate the FD and PI
!! coefficients, or CBC coefficients, with the appropriate
!! targets, based on the coordinate direction and location
!! of the CBC.
!! @param cbc_dir CBC coordinate direction
!! @param cbc_loc CBC coordinate location
SUBROUTINE s_associate_cbc_coefficients_pointers(cbc_dir, cbc_loc) ! ---
INTEGER, INTENT(IN) :: cbc_dir, cbc_loc
INTEGER :: i !< Generic loop iterator
! Associating CBC Coefficients in x-direction ======================
IF(cbc_dir == 1) THEN
fd_coef => fd_coef_x; IF(weno_order > 1) pi_coef => pi_coef_x
IF(cbc_loc == -1) THEN
DO i = 0, buff_size
ds(i) = dx( i )
END DO
ELSE
DO i = 0, buff_size
ds(i) = dx(m-i)
END DO
END IF
! ==================================================================
! Associating CBC Coefficients in y-direction ======================
ELSEIF(cbc_dir == 2) THEN
fd_coef => fd_coef_y; IF(weno_order > 1) pi_coef => pi_coef_y
IF(cbc_loc == -1) THEN
DO i = 0, buff_size
ds(i) = dy( i )
END DO
ELSE
DO i = 0, buff_size
ds(i) = dy(n-i)
END DO
END IF
! ==================================================================
! Associating CBC Coefficients in z-direction ======================
ELSE
fd_coef => fd_coef_z; IF(weno_order > 1) pi_coef => pi_coef_z
IF(cbc_loc == -1) THEN
DO i = 0, buff_size
ds(i) = dz( i )
END DO
ELSE
DO i = 0, buff_size
ds(i) = dz(p-i)
END DO
END IF
END IF
! ==================================================================
END SUBROUTINE s_associate_cbc_coefficients_pointers ! -----------------
!> The following is the implementation of the CBC based on
!! the work of Thompson (1987, 1990) on hyperbolic systems.
!! The CBC is indirectly applied in the computation of the
!! right-hand-side (RHS) near the relevant domain boundary
!! through the modification of the fluxes.
!! @param q_prim_vf Cell-average primitive variables
!! @param flux_vf Cell-boundary-average fluxes
!! @param flux_src_vf Cell-boundary-average flux sources
!! @param cbc_dir CBC coordinate direction
!! @param cbc_loc CBC coordinate location
!! @param ix Index bound in the first coordinate direction
!! @param iy Index bound in the second coordinate direction
!! @param iz Index bound in the third coordinate direction
SUBROUTINE s_cbc( q_prim_vf, flux_vf, flux_src_vf, & ! -----------------
cbc_dir, cbc_loc, &
ix,iy,iz )
TYPE(scalar_field), &
DIMENSION(sys_size), &
INTENT(IN) :: q_prim_vf
TYPE(scalar_field), &
DIMENSION(sys_size), &
INTENT(INOUT) :: flux_vf, flux_src_vf
INTEGER, INTENT(IN) :: cbc_dir, cbc_loc
TYPE(bounds_info), INTENT(IN) :: ix,iy,iz
! First-order time derivatives of the partial densities, density,
! velocity, pressure, advection variables, and the specific heat
! ratio and liquid stiffness functions
REAL(KIND(0d0)), DIMENSION(cont_idx%end) :: dalpha_rho_dt
REAL(KIND(0d0)) :: drho_dt
REAL(KIND(0d0)), DIMENSION(num_dims) :: dvel_dt
REAL(KIND(0d0)) :: dpres_dt
REAL(KIND(0d0)), DIMENSION(adv_idx%end-E_idx) :: dadv_dt
REAL(KIND(0d0)) :: dgamma_dt
REAL(KIND(0d0)) :: dpi_inf_dt
INTEGER :: i,j,k,r !< Generic loop iterators
REAL(KIND(0d0)) :: blkmod1, blkmod2 !< Fluid bulk modulus for Wood mixture sound speed
! Reshaping of inputted data and association of the FD and PI
! coefficients, or CBC coefficients, respectively, hinging on
! selected CBC coordinate direction
CALL s_initialize_cbc( q_prim_vf, flux_vf, flux_src_vf, &
cbc_dir, cbc_loc, &
ix,iy,iz )
CALL s_associate_cbc_coefficients_pointers(cbc_dir, cbc_loc)
! PI2 of flux_rs_vf and flux_src_rs_vf at j = 1/2 ==================
IF(weno_order == 3) THEN
CALL s_convert_primitive_to_flux_variables( q_prim_rs_vf, &
F_rs_vf, &
F_src_rs_vf, &
is1,is2,is3 )
DO i = 1, adv_idx%end
flux_rs_vf(i)%sf(0,:,:) = F_rs_vf(i)%sf(0,:,:) &
+ pi_coef(0,0,cbc_loc) * &
( F_rs_vf(i)%sf(1,:,:) - &
F_rs_vf(i)%sf(0,:,:) )
END DO
DO i = adv_idx%beg, adv_idx%end
flux_src_rs_vf(i)%sf(0,:,:) = F_src_rs_vf(i)%sf(0,:,:) + &
( F_src_rs_vf(i)%sf(1,:,:) - &
F_src_rs_vf(i)%sf(0,:,:) ) &
* pi_coef(0,0,cbc_loc)
END DO
! ==================================================================
! PI4 of flux_rs_vf and flux_src_rs_vf at j = 1/2, 3/2 =============
ELSEIF(weno_order == 5) THEN
CALL s_convert_primitive_to_flux_variables( q_prim_rs_vf, &
F_rs_vf, &
F_src_rs_vf, &
is1,is2,is3 )
DO i = 1, adv_idx%end
DO j = 0,1
flux_rs_vf(i)%sf(j,:,:) = F_rs_vf(i)%sf(j,:,:) &
+ pi_coef(j,0,cbc_loc) * &
( F_rs_vf(i)%sf(3,:,:) - &
F_rs_vf(i)%sf(2,:,:) ) &
+ pi_coef(j,1,cbc_loc) * &
( F_rs_vf(i)%sf(2,:,:) - &
F_rs_vf(i)%sf(1,:,:) ) &
+ pi_coef(j,2,cbc_loc) * &
( F_rs_vf(i)%sf(1,:,:) - &
F_rs_vf(i)%sf(0,:,:) )
END DO
END DO
DO i = adv_idx%beg, adv_idx%end
DO j = 0,1
flux_src_rs_vf(i)%sf(j,:,:) = F_src_rs_vf(i)%sf(j,:,:) + &
( F_src_rs_vf(i)%sf(3,:,:) - &
F_src_rs_vf(i)%sf(2,:,:) ) &
* pi_coef(j,0,cbc_loc) + &
( F_src_rs_vf(i)%sf(2,:,:) - &
F_src_rs_vf(i)%sf(1,:,:) ) &
* pi_coef(j,1,cbc_loc) + &
( F_src_rs_vf(i)%sf(1,:,:) - &
F_src_rs_vf(i)%sf(0,:,:) ) &
* pi_coef(j,2,cbc_loc)
END DO
END DO
END IF
! ==================================================================
! FD2 or FD4 of RHS at j = 0 =======================================
DO r = is3%beg, is3%end
DO k = is2%beg, is2%end
! Transferring the Primitive Variables =======================
DO i = 1, cont_idx%end
alpha_rho(i) = q_prim_rs_vf(i)%sf(0,k,r)
END DO
DO i = 1, num_dims
vel(i) = q_prim_rs_vf(cont_idx%end+i)%sf(0,k,r)
END DO
pres = q_prim_rs_vf(E_idx)%sf(0,k,r)
CALL s_convert_to_mixture_variables( q_prim_rs_vf, &
rho, gamma, &
pi_inf, Re, &
We, 0,k,r )
E = gamma*pres + pi_inf + 5d-1*rho*SUM(vel**2d0)
H = (E + pres)/rho
DO i = 1, adv_idx%end-E_idx
adv(i) = q_prim_rs_vf(E_idx+i)%sf(0,k,r)
END DO
mf = alpha_rho/rho
! Compute mixture sound speed
IF (alt_soundspeed .OR. regularization) THEN
blkmod1 = ((fluid_pp(1)%gamma +1d0)*pres + &
fluid_pp(1)%pi_inf)/fluid_pp(1)%gamma
blkmod2 = ((fluid_pp(2)%gamma +1d0)*pres + &
fluid_pp(2)%pi_inf)/fluid_pp(2)%gamma
c = (1d0/(rho*(adv(1)/blkmod1 + adv(2)/blkmod2)))
ELSEIF(model_eqns == 3) THEN
c = 0d0
DO i = 1, num_fluids
c = c + q_prim_rs_vf(i+adv_idx%beg-1)%sf(0,k,r) * (1d0/fluid_pp(i)%gamma+1d0) * &
(pres + fluid_pp(i)%pi_inf/(fluid_pp(i)%gamma+1d0))
END DO
c = c/rho
ELSE
c = ((H - 5d-1*SUM(vel**2d0))/gamma)
END IF
c = SQRT(c)
! IF (mixture_err .AND. c < 0d0) THEN
! c = sgm_eps
! ELSE
! c = SQRT(c)
! END IF
! ============================================================
! First-Order Spatial Derivatives of Primitive Variables =====
dalpha_rho_ds = 0d0
dvel_ds = 0d0
dpres_ds = 0d0
dadv_ds = 0d0
DO j = 0, buff_size
DO i = 1, cont_idx%end
dalpha_rho_ds(i) = q_prim_rs_vf(i)%sf(j,k,r) * &
fd_coef(j,cbc_loc) + &
dalpha_rho_ds(i)
END DO
DO i = 1, num_dims
dvel_ds(i) = q_prim_rs_vf(cont_idx%end+i)%sf(j,k,r) * &
fd_coef(j,cbc_loc) + &
dvel_ds(i)
END DO
dpres_ds = q_prim_rs_vf(E_idx)%sf(j,k,r) * &
fd_coef(j,cbc_loc) + &
dpres_ds
DO i = 1, adv_idx%end-E_idx
dadv_ds(i) = q_prim_rs_vf(E_idx+i)%sf(j,k,r) * &
fd_coef(j,cbc_loc) + &
dadv_ds(i)
END DO
END DO
! ============================================================
! First-Order Temporal Derivatives of Primitive Variables ====
lambda(1) = vel(dir_idx(1)) - c
lambda(2) = vel(dir_idx(1))
lambda(3) = vel(dir_idx(1)) + c
CALL s_compute_L(dflt_int)
! Be careful about the cylindrical coordinate!
IF(cyl_coord .AND. cbc_dir == 2 .AND. cbc_loc == 1 ) THEN
dpres_dt = -5d-1*(L(adv_idx%end) + L(1)) + rho*c*c*vel(dir_idx(1)) &
/ y_cc(n)
ELSE
dpres_dt = -5d-1*(L(adv_idx%end) + L(1))
END IF
DO i = 1, cont_idx%end
dalpha_rho_dt(i) = &
-(L(i+1) - mf(i)*dpres_dt)/(c*c)
END DO
DO i = 1, num_dims
dvel_dt(dir_idx(i)) = dir_flg(dir_idx(i)) * &
(L(1) - L(adv_idx%end))/(2d0*rho*c) + &
(dir_flg(dir_idx(i)) - 1d0) * &
L(mom_idx%beg+i)
END DO
! The treatment of void fraction source is unclear
IF(cyl_coord .AND. cbc_dir == 2 .AND. cbc_loc == 1 ) THEN
DO i = 1, adv_idx%end-E_idx
dadv_dt(i) = -L(mom_idx%end+i) !+ adv(i) * vel(dir_idx(1))/y_cc(n)
END DO
ELSE
DO i = 1, adv_idx%end-E_idx
dadv_dt(i) = -L(mom_idx%end+i)
END DO
END IF
drho_dt = 0d0; dgamma_dt = 0d0; dpi_inf_dt = 0d0
IF(model_eqns == 1) THEN
drho_dt = dalpha_rho_dt(1)
dgamma_dt = dadv_dt(1)
dpi_inf_dt = dadv_dt(2)
ELSE
DO i = 1, num_fluids
drho_dt = drho_dt + dalpha_rho_dt(i)
dgamma_dt = dgamma_dt + dadv_dt(i)*fluid_pp(i)%gamma
dpi_inf_dt = dpi_inf_dt + dadv_dt(i)*fluid_pp(i)%pi_inf
END DO
END IF
! ============================================================
! flux_rs_vf and flux_src_rs_vf at j = -1/2 ==================
DO i = 1, cont_idx%end
flux_rs_vf(i)%sf(-1,k,r) = flux_rs_vf(i)%sf(0,k,r) &
+ ds(0)*dalpha_rho_dt(i)
END DO
DO i = mom_idx%beg, mom_idx%end
flux_rs_vf(i)%sf(-1,k,r) = flux_rs_vf(i)%sf(0,k,r) &
+ ds(0)*( vel(i-cont_idx%end)*drho_dt &
+ rho*dvel_dt(i-cont_idx%end) )
END DO
flux_rs_vf(E_idx)%sf(-1,k,r) = flux_rs_vf(E_idx)%sf(0,k,r) &
+ ds(0)*( pres*dgamma_dt &
+ gamma*dpres_dt &
+ dpi_inf_dt &
+ rho*SUM(vel*dvel_dt) &
+ 5d-1*drho_dt*SUM(vel**2d0) )
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg, adv_idx%end
flux_rs_vf(i)%sf(-1,k,r) = 0d0
END DO
DO i = adv_idx%beg, adv_idx%end
flux_src_rs_vf(i)%sf(-1,k,r) = &
1d0/MAX(ABS(vel(dir_idx(1))),sgm_eps) &
* SIGN(1d0,vel(dir_idx(1))) &
* ( flux_rs_vf(i)%sf(0,k,r) &
+ vel(dir_idx(1)) &
* flux_src_rs_vf(i)%sf(0,k,r) &
+ ds(0)*dadv_dt(i-E_idx) )
END DO
ELSE
DO i = adv_idx%beg, adv_idx%end
flux_rs_vf(i)%sf(-1,k,r) = flux_rs_vf(i)%sf(0,k,r) - &
adv(i-E_idx)*flux_src_rs_vf(i)%sf(0,k,r) + &
ds(0)*dadv_dt(i-E_idx)
END DO
DO i = adv_idx%beg, adv_idx%end
flux_src_rs_vf(i)%sf(-1,k,r) = 0d0
END DO
END IF
! END: flux_rs_vf and flux_src_rs_vf at j = -1/2 =============
END DO
END DO
! END: FD2 or FD4 of RHS at j = 0 ==================================
! The reshaping of outputted data and disssociation of the FD and PI
! coefficients, or CBC coefficients, respectively, based on selected
! CBC coordinate direction.
CALL s_finalize_cbc( flux_vf, flux_src_vf, &
cbc_dir, cbc_loc, &
ix,iy,iz )
NULLIFY(fd_coef, pi_coef)
END SUBROUTINE s_cbc ! -------------------------------------------------
!> The L variables for the slip wall CBC, see pg. 451 of
!! Thompson (1990). At the slip wall (frictionless wall),
!! the normal component of velocity is zero at all times,
!! while the transverse velocities may be nonzero.
!! @param dflt_int Default null integer
SUBROUTINE s_compute_slip_wall_L(dflt_int) ! -----------------------------------
INTEGER, INTENT(IN) :: dflt_int
L(1) = lambda(1)*(dpres_ds - rho*c*dvel_ds(dir_idx(1)))
L(2:adv_idx%end-1) = 0d0
L(adv_idx%end) = L(1)
END SUBROUTINE s_compute_slip_wall_L ! ---------------------------------
!> The L variables for the nonreflecting subsonic buffer CBC
!! see pg. 13 of Thompson (1987). The nonreflecting subsonic
!! buffer reduces the amplitude of any reflections caused by
!! outgoing waves.
!! @param dflt_int Default null integer
SUBROUTINE s_compute_nonreflecting_subsonic_buffer_L(dflt_int) ! ---------------
INTEGER, INTENT(IN) :: dflt_int
INTEGER :: i !< Generic loop iterator
L(1) = (5d-1 - 5d-1*SIGN(1d0,lambda(1)))*lambda(1) &
* (dpres_ds - rho*c*dvel_ds(dir_idx(1)))
DO i = 2, mom_idx%beg
L(i) = (5d-1 - 5d-1*SIGN(1d0,lambda(2)))*lambda(2) &
* (c*c*dalpha_rho_ds(i-1) - mf(i-1)*dpres_ds)
END DO
DO i = mom_idx%beg+1, mom_idx%end
L(i) = (5d-1 - 5d-1*SIGN(1d0,lambda(2)))*lambda(2) &
* (dvel_ds(dir_idx(i-cont_idx%end)))
END DO
DO i = E_idx, adv_idx%end-1
L(i) = (5d-1 - 5d-1*SIGN(1d0,lambda(2)))*lambda(2) &
* (dadv_ds(i-mom_idx%end))
END DO
L(adv_idx%end) = (5d-1 - 5d-1*SIGN(1d0,lambda(3)))*lambda(3) &
* (dpres_ds + rho*c*dvel_ds(dir_idx(1)))
END SUBROUTINE s_compute_nonreflecting_subsonic_buffer_L ! -------------
!> The L variables for the nonreflecting subsonic inflow CBC
!! see pg. 455, Thompson (1990). This nonreflecting subsonic
!! CBC assumes an incoming flow and reduces the amplitude of
!! any reflections caused by outgoing waves.
!! @param dflt_int Default null integer
SUBROUTINE s_compute_nonreflecting_subsonic_inflow_L(dflt_int) ! ---------------
INTEGER, INTENT(IN) :: dflt_int
L(1) = lambda(1)*(dpres_ds - rho*c*dvel_ds(dir_idx(1)))
L(2:adv_idx%end) = 0d0
END SUBROUTINE s_compute_nonreflecting_subsonic_inflow_L ! -------------
!> The L variables for the nonreflecting subsonic outflow
!! CBC see pg. 454 of Thompson (1990). This nonreflecting
!! subsonic CBC presumes an outgoing flow and reduces the
!! amplitude of any reflections caused by outgoing waves.
!! @param dflt_int Default null integer
SUBROUTINE s_compute_nonreflecting_subsonic_outflow_L(dflt_int) ! --------------
INTEGER, INTENT(IN) :: dflt_int
INTEGER :: i !> Generic loop iterator
L(1) = lambda(1)*(dpres_ds - rho*c*dvel_ds(dir_idx(1)))
DO i = 2, mom_idx%beg
L(i) = lambda(2)*(c*c*dalpha_rho_ds(i-1) - mf(i-1)*dpres_ds)
END DO
DO i = mom_idx%beg+1, mom_idx%end
L(i) = lambda(2)*(dvel_ds(dir_idx(i-cont_idx%end)))
END DO
DO i = E_idx, adv_idx%end-1
L(i) = lambda(2)*(dadv_ds(i-mom_idx%end))
END DO
! bubble index
L(adv_idx%end) = 0d0
END SUBROUTINE s_compute_nonreflecting_subsonic_outflow_L ! ------------
!> The L variables for the force-free subsonic outflow CBC,
!! see pg. 454 of Thompson (1990). The force-free subsonic
!! outflow sets to zero the sum of all of the forces which
!! are acting on a fluid element for the normal coordinate
!! direction to the boundary. As a result, a fluid element
!! at the boundary is simply advected outward at the fluid
!! velocity.
!! @param dflt_int Default null integer
SUBROUTINE s_compute_force_free_subsonic_outflow_L(dflt_int) ! -----------------
INTEGER, INTENT(IN) :: dflt_int
INTEGER :: i !> Generic loop iterator
L(1) = lambda(1)*(dpres_ds - rho*c*dvel_ds(dir_idx(1)))
DO i = 2, mom_idx%beg
L(i) = lambda(2)*(c*c*dalpha_rho_ds(i-1) - mf(i-1)*dpres_ds)
END DO
DO i = mom_idx%beg+1, mom_idx%end
L(i) = lambda(2)*(dvel_ds(dir_idx(i-cont_idx%end)))
END DO
DO i = E_idx, adv_idx%end-1
L(i) = lambda(2)*(dadv_ds(i-mom_idx%end))
END DO
L(adv_idx%end) = L(1) + 2d0*rho*c*lambda(2)*dvel_ds(dir_idx(1))
END SUBROUTINE s_compute_force_free_subsonic_outflow_L ! ---------------
!> L variables for the constant pressure subsonic outflow
!! CBC see pg. 455 Thompson (1990). The constant pressure
!! subsonic outflow maintains a fixed pressure at the CBC
!! boundary in absence of any transverse effects.
!! @param dflt_int Default null integer
SUBROUTINE s_compute_constant_pressure_subsonic_outflow_L(dflt_int) ! ----------
INTEGER, INTENT(IN) :: dflt_int
INTEGER :: i !> Generic loop iterator
L(1) = lambda(1)*(dpres_ds - rho*c*dvel_ds(dir_idx(1)))
DO i = 2, mom_idx%beg
L(i) = lambda(2)*(c*c*dalpha_rho_ds(i-1) - mf(i-1)*dpres_ds)
END DO
DO i = mom_idx%beg+1, mom_idx%end
L(i) = lambda(2)*(dvel_ds(dir_idx(i-cont_idx%end)))
END DO
DO i = E_idx, adv_idx%end-1
L(i) = lambda(2)*(dadv_ds(i-mom_idx%end))
END DO
L(adv_idx%end) = -L(1)
END SUBROUTINE s_compute_constant_pressure_subsonic_outflow_L ! --------
!> L variables for the supersonic inflow CBC, see pg. 453
!! Thompson (1990). The supersonic inflow CBC is a steady
!! state, or nearly a steady state, CBC in which only the
!! transverse terms may generate a time dependence at the
!! inflow boundary.
!! @param dflt_int Default null integer
SUBROUTINE s_compute_supersonic_inflow_L(dflt_int) ! ---------------------------
INTEGER, INTENT(IN) :: dflt_int
L = 0d0
END SUBROUTINE s_compute_supersonic_inflow_L ! -------------------------
!> L variables for the supersonic outflow CBC, see pg. 453
!! of Thompson (1990). For the supersonic outflow CBC, the
!! flow evolution at the boundary is determined completely
!! by the interior data.
!! @param dflt_int Default null integer
SUBROUTINE s_compute_supersonic_outflow_L(dflt_int) ! --------------------------
INTEGER, INTENT(IN) :: dflt_int
INTEGER :: i !< Generic loop iterator
L(1) = lambda(1)*(dpres_ds - rho*c*dvel_ds(dir_idx(1)))
DO i = 2, mom_idx%beg
L(i) = lambda(2)*(c*c*dalpha_rho_ds(i-1) - mf(i-1)*dpres_ds)
END DO
DO i = mom_idx%beg+1, mom_idx%end
L(i) = lambda(2)*(dvel_ds(dir_idx(i-cont_idx%end)))
END DO
DO i = E_idx, adv_idx%end-1
L(i) = lambda(2)*(dadv_ds(i-mom_idx%end))
END DO
L(adv_idx%end) = lambda(3)*(dpres_ds + rho*c*dvel_ds(dir_idx(1)))
END SUBROUTINE s_compute_supersonic_outflow_L ! ------------------------
!> The computation of parameters, the allocation of memory,
!! the association of pointers and/or the execution of any
!! other procedures that are required for the setup of the
!! selected CBC.
!! @param q_prim_vf Cell-average primitive variables
!! @param flux_vf Cell-boundary-average fluxes
!! @param flux_src_vf Cell-boundary-average flux sources
!! @param cbc_dir CBC coordinate direction
!! @param cbc_loc CBC coordinate location
!! @param ix Index bound in the first coordinate direction
!! @param iy Index bound in the second coordinate direction
!! @param iz Index bound in the third coordinate direction
SUBROUTINE s_initialize_cbc( q_prim_vf, flux_vf, flux_src_vf, & ! ------
cbc_dir, cbc_loc, &
ix,iy,iz )
TYPE(scalar_field), &
DIMENSION(sys_size), &
INTENT(IN) :: q_prim_vf
TYPE(scalar_field), &
DIMENSION(sys_size), &
INTENT(IN) :: flux_vf, flux_src_vf
INTEGER, INTENT(IN) :: cbc_dir, cbc_loc
TYPE(bounds_info), INTENT(IN) :: ix,iy,iz
INTEGER :: dj !< Indical shift based on CBC location
INTEGER :: i,j,k,r !< Generic loop iterators
! Configuring the coordinate direction indexes and flags
IF(cbc_dir == 1) THEN
is1%beg = 0; is1%end = buff_size; is2 = iy; is3 = iz
dir_idx = (/1,2,3/); dir_flg = (/1d0,0d0,0d0/)
ELSEIF(cbc_dir == 2) THEN
is1%beg = 0; is1%end = buff_size; is2 = ix; is3 = iz
dir_idx = (/2,1,3/); dir_flg = (/0d0,1d0,0d0/)
ELSE
is1%beg = 0; is1%end = buff_size; is2 = iy; is3 = ix
dir_idx = (/3,1,2/); dir_flg = (/0d0,0d0,1d0/)
END IF
! Determining the indicial shift based on CBC location
dj = MAX(0,cbc_loc)
! Allocation/Association of Primitive and Flux Variables ===========
DO i = 1, sys_size
ALLOCATE(q_prim_rs_vf(i)%sf( 0 : buff_size, &
is2%beg : is2%end , &
is3%beg : is3%end ))
END DO
IF(weno_order > 1) THEN
DO i = 1, adv_idx%end
ALLOCATE(F_rs_vf(i)%sf( 0 : buff_size, &
is2%beg : is2%end , &
is3%beg : is3%end ))
END DO
ALLOCATE(F_src_rs_vf(adv_idx%beg)%sf( 0 : buff_size, &
is2%beg : is2%end , &
is3%beg : is3%end ))
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
ALLOCATE(F_src_rs_vf(i)%sf( 0 : buff_size, &
is2%beg : is2%end , &
is3%beg : is3%end ))
END DO
ELSE
DO i = adv_idx%beg+1, adv_idx%end
F_src_rs_vf(i)%sf => F_src_rs_vf(adv_idx%beg)%sf
END DO
END IF
END IF
DO i = 1, adv_idx%end
ALLOCATE(flux_rs_vf(i)%sf( -1 : buff_size, &
is2%beg : is2%end , &
is3%beg : is3%end ))
END DO
ALLOCATE(flux_src_rs_vf(adv_idx%beg)%sf( -1 : buff_size, &
is2%beg : is2%end , &
is3%beg : is3%end ))
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
ALLOCATE(flux_src_rs_vf(i)%sf( -1 : buff_size, &
is2%beg : is2%end , &
is3%beg : is3%end ))
END DO
ELSE
DO i = adv_idx%beg+1, adv_idx%end
flux_src_rs_vf(i)%sf => flux_src_rs_vf(adv_idx%beg)%sf
END DO
END IF
! END: Allocation/Association of Primitive and Flux Variables ======
! Reshaping Inputted Data in x-direction ===========================
IF(cbc_dir == 1) THEN
DO i = 1, sys_size
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = 0, buff_size
q_prim_rs_vf(i)%sf(j,k,r) = &
q_prim_vf(i)%sf(dj*(m-2*j)+j,k,r)
END DO
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = 0, buff_size
q_prim_rs_vf(mom_idx%beg)%sf(j,k,r) = &
q_prim_vf(mom_idx%beg)%sf(dj*(m-2*j)+j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
DO i = 1, adv_idx%end
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_rs_vf(i)%sf(j,k,r) = &
flux_vf(i)%sf(dj*((m-1)-2*j)+j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_rs_vf(mom_idx%beg)%sf(j,k,r) = &
flux_vf(mom_idx%beg)%sf(dj*((m-1)-2*j)+j,k,r)
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) = &
flux_src_vf(adv_idx%beg)%sf(dj*((m-1)-2*j)+j,k,r)
END DO
END DO
END DO
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_rs_vf(i)%sf(j,k,r) = &
flux_src_vf(i)%sf(dj*((m-1)-2*j)+j,k,r)
END DO
END DO
END DO
END DO
ELSE
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) = &
flux_src_vf(adv_idx%beg)%sf(dj*((m-1)-2*j)+j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END IF
! END: Reshaping Inputted Data in x-direction ======================
! Reshaping Inputted Data in y-direction ===========================
ELSEIF(cbc_dir == 2) THEN
DO i = 1, sys_size
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = 0, buff_size
q_prim_rs_vf(i)%sf(j,k,r) = &
q_prim_vf(i)%sf(k,dj*(n-2*j)+j,r)
END DO
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = 0, buff_size
q_prim_rs_vf(mom_idx%beg+1)%sf(j,k,r) = &
q_prim_vf(mom_idx%beg+1)%sf(k,dj*(n-2*j)+j,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
DO i = 1, adv_idx%end
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_rs_vf(i)%sf(j,k,r) = &
flux_vf(i)%sf(k,dj*((n-1)-2*j)+j,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_rs_vf(mom_idx%beg+1)%sf(j,k,r) = &
flux_vf(mom_idx%beg+1)%sf(k,dj*((n-1)-2*j)+j,r)
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) = &
flux_src_vf(adv_idx%beg)%sf(k,dj*((n-1)-2*j)+j,r)
END DO
END DO
END DO
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_src_rs_vf(i)%sf(j,k,r) = &
flux_src_vf(i)%sf(k,dj*((n-1)-2*j)+j,r)
END DO
END DO
END DO
END DO
ELSE
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) = &
flux_src_vf(adv_idx%beg)%sf(k,dj*((n-1)-2*j)+j,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END IF
! END: Reshaping Inputted Data in y-direction ======================
! Reshaping Inputted Data in z-direction ===========================
ELSE
DO i = 1, sys_size
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = 0, buff_size
q_prim_rs_vf(i)%sf(j,k,r) = &
q_prim_vf(i)%sf(r,k,dj*(p-2*j)+j)
END DO
END DO
END DO
END DO
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = 0, buff_size
q_prim_rs_vf(mom_idx%end)%sf(j,k,r) = &
q_prim_vf(mom_idx%end)%sf(r,k,dj*(p-2*j)+j) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
DO i = 1, adv_idx%end
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_rs_vf(i)%sf(j,k,r) = &
flux_vf(i)%sf(r,k,dj*((p-1)-2*j)+j) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END DO
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_rs_vf(mom_idx%end)%sf(j,k,r) = &
flux_vf(mom_idx%end)%sf(r,k,dj*((p-1)-2*j)+j)
END DO
END DO
END DO
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) = &
flux_src_vf(adv_idx%beg)%sf(r,k,dj*((p-1)-2*j)+j)
END DO
END DO
END DO
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_rs_vf(i)%sf(j,k,r) = &
flux_src_vf(i)%sf(r,k,dj*((p-1)-2*j)+j)
END DO
END DO
END DO
END DO
ELSE
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) = &
flux_src_vf(adv_idx%beg)%sf(r,k,dj*((p-1)-2*j)+j) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END IF
END IF
! END: Reshaping Inputted Data in z-direction ======================
! Association of the procedural pointer to the appropriate procedure
! that will be utilized in the evaluation of L variables for the CBC
! ==================================================================
IF( (cbc_dir == 1 .AND. cbc_loc == -1 .AND. bc_x%beg == -5) &
.OR. (cbc_dir == 1 .AND. cbc_loc == 1 .AND. bc_x%end == -5) &
.OR. (cbc_dir == 2 .AND. cbc_loc == -1 .AND. bc_y%beg == -5) &
.OR. (cbc_dir == 2 .AND. cbc_loc == 1 .AND. bc_y%end == -5) &
.OR. (cbc_dir == 3 .AND. cbc_loc == -1 .AND. bc_z%beg == -5) &
.OR. (cbc_dir == 3 .AND. cbc_loc == 1 .AND. bc_z%end == -5) ) &
THEN
s_compute_L => s_compute_slip_wall_L
ELSEIF( (cbc_dir == 1 .AND. cbc_loc == -1 .AND. bc_x%beg == -6) &
.OR. (cbc_dir == 1 .AND. cbc_loc == 1 .AND. bc_x%end == -6) &
.OR. (cbc_dir == 2 .AND. cbc_loc == -1 .AND. bc_y%beg == -6) &
.OR. (cbc_dir == 2 .AND. cbc_loc == 1 .AND. bc_y%end == -6) &
.OR. (cbc_dir == 3 .AND. cbc_loc == -1 .AND. bc_z%beg == -6) &
.OR. (cbc_dir == 3 .AND. cbc_loc == 1 .AND. bc_z%end == -6) ) &
THEN
s_compute_L => s_compute_nonreflecting_subsonic_buffer_L
ELSEIF( (cbc_dir == 1 .AND. cbc_loc == -1 .AND. bc_x%beg == -7) &
.OR. (cbc_dir == 1 .AND. cbc_loc == 1 .AND. bc_x%end == -7) &
.OR. (cbc_dir == 2 .AND. cbc_loc == -1 .AND. bc_y%beg == -7) &
.OR. (cbc_dir == 2 .AND. cbc_loc == 1 .AND. bc_y%end == -7) &
.OR. (cbc_dir == 3 .AND. cbc_loc == -1 .AND. bc_z%beg == -7) &
.OR. (cbc_dir == 3 .AND. cbc_loc == 1 .AND. bc_z%end == -7) ) &
THEN
s_compute_L => s_compute_nonreflecting_subsonic_inflow_L
ELSEIF( (cbc_dir == 1 .AND. cbc_loc == -1 .AND. bc_x%beg == -8) &
.OR. (cbc_dir == 1 .AND. cbc_loc == 1 .AND. bc_x%end == -8) &
.OR. (cbc_dir == 2 .AND. cbc_loc == -1 .AND. bc_y%beg == -8) &
.OR. (cbc_dir == 2 .AND. cbc_loc == 1 .AND. bc_y%end == -8) &
.OR. (cbc_dir == 3 .AND. cbc_loc == -1 .AND. bc_z%beg == -8) &
.OR. (cbc_dir == 3 .AND. cbc_loc == 1 .AND. bc_z%end == -8) ) &
THEN
s_compute_L => s_compute_nonreflecting_subsonic_outflow_L
ELSEIF( (cbc_dir == 1 .AND. cbc_loc == -1 .AND. bc_x%beg == -9) &
.OR. (cbc_dir == 1 .AND. cbc_loc == 1 .AND. bc_x%end == -9) &
.OR. (cbc_dir == 2 .AND. cbc_loc == -1 .AND. bc_y%beg == -9) &
.OR. (cbc_dir == 2 .AND. cbc_loc == 1 .AND. bc_y%end == -9) &
.OR. (cbc_dir == 3 .AND. cbc_loc == -1 .AND. bc_z%beg == -9) &
.OR. (cbc_dir == 3 .AND. cbc_loc == 1 .AND. bc_z%end == -9) ) &
THEN
s_compute_L => s_compute_force_free_subsonic_outflow_L
ELSEIF( (cbc_dir == 1 .AND. cbc_loc == -1 .AND. bc_x%beg ==-10) &
.OR. (cbc_dir == 1 .AND. cbc_loc == 1 .AND. bc_x%end ==-10) &
.OR. (cbc_dir == 2 .AND. cbc_loc == -1 .AND. bc_y%beg ==-10) &
.OR. (cbc_dir == 2 .AND. cbc_loc == 1 .AND. bc_y%end ==-10) &
.OR. (cbc_dir == 3 .AND. cbc_loc == -1 .AND. bc_z%beg ==-10) &
.OR. (cbc_dir == 3 .AND. cbc_loc == 1 .AND. bc_z%end ==-10) ) &
THEN
s_compute_L => s_compute_constant_pressure_subsonic_outflow_L
ELSEIF( (cbc_dir == 1 .AND. cbc_loc == -1 .AND. bc_x%beg ==-11) &
.OR. (cbc_dir == 1 .AND. cbc_loc == 1 .AND. bc_x%end ==-11) &
.OR. (cbc_dir == 2 .AND. cbc_loc == -1 .AND. bc_y%beg ==-11) &
.OR. (cbc_dir == 2 .AND. cbc_loc == 1 .AND. bc_y%end ==-11) &
.OR. (cbc_dir == 3 .AND. cbc_loc == -1 .AND. bc_z%beg ==-11) &
.OR. (cbc_dir == 3 .AND. cbc_loc == 1 .AND. bc_z%end ==-11) ) &
THEN
s_compute_L => s_compute_supersonic_inflow_L
ELSE
s_compute_L => s_compute_supersonic_outflow_L
END IF
! ==================================================================
END SUBROUTINE s_initialize_cbc ! --------------------------------------
!> Deallocation and/or the disassociation procedures that
!! are necessary in order to finalize the CBC application
!! @param flux_vf Cell-boundary-average fluxes
!! @param flux_src_vf Cell-boundary-average flux sources
!! @param cbc_dir CBC coordinate direction
!! @param cbc_loc CBC coordinate location
!! @param ix Index bound in the first coordinate direction
!! @param iy Index bound in the second coordinate direction
!! @param iz Index bound in the third coordinate direction
SUBROUTINE s_finalize_cbc( flux_vf, flux_src_vf, & ! -------------------
cbc_dir, cbc_loc, &
ix,iy,iz )
TYPE(scalar_field), &
DIMENSION(sys_size), &
INTENT(INOUT) :: flux_vf, flux_src_vf
INTEGER, INTENT(IN) :: cbc_dir, cbc_loc
TYPE(bounds_info), INTENT(IN) :: ix,iy,iz
INTEGER :: dj !< Indical shift based on CBC location
INTEGER :: i,j,k,r !< Generic loop iterators
! Determining the indicial shift based on CBC location
dj = MAX(0,cbc_loc)
! Reshaping Outputted Data in x-direction ==========================
IF(cbc_dir == 1) THEN
DO i = 1, adv_idx%end
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_vf(i)%sf(dj*((m-1)-2*j)+j,k,r) = &
flux_rs_vf(i)%sf(j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_vf(mom_idx%beg)%sf(dj*((m-1)-2*j)+j,k,r) = &
flux_rs_vf(mom_idx%beg)%sf(j,k,r)
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_vf(adv_idx%beg)%sf(dj*((m-1)-2*j)+j,k,r) = &
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r)
END DO
END DO
END DO
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_vf(i)%sf(dj*((m-1)-2*j)+j,k,r) = &
flux_src_rs_vf(i)%sf(j,k,r)
END DO
END DO
END DO
END DO
ELSE
DO r = iz%beg, iz%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_vf(adv_idx%beg)%sf(dj*((m-1)-2*j)+j,k,r) = &
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END IF
! END: Reshaping Outputted Data in x-direction =====================
! Reshaping Outputted Data in y-direction ==========================
ELSEIF(cbc_dir == 2) THEN
DO i = 1, adv_idx%end
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_vf(i)%sf(k,dj*((n-1)-2*j)+j,r) = &
flux_rs_vf(i)%sf(j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_vf(mom_idx%beg+1)%sf(k,dj*((n-1)-2*j)+j,r) = &
flux_rs_vf(mom_idx%beg+1)%sf(j,k,r)
END DO
END DO
END DO
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_src_vf(adv_idx%beg)%sf(k,dj*((n-1)-2*j)+j,r) = &
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r)
END DO
END DO
END DO
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_src_vf(i)%sf(k,dj*((n-1)-2*j)+j,r) = &
flux_src_rs_vf(i)%sf(j,k,r)
END DO
END DO
END DO
END DO
ELSE
DO r = iz%beg, iz%end
DO k = ix%beg, ix%end
DO j = -1, buff_size
flux_src_vf(adv_idx%beg)%sf(k,dj*((n-1)-2*j)+j,r) = &
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END IF
! END: Reshaping Outputted Data in y-direction =====================
! Reshaping Outputted Data in z-direction ==========================
ELSE
DO i = 1, adv_idx%end
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_vf(i)%sf(r,k,dj*((p-1)-2*j)+j) = &
flux_rs_vf(i)%sf(j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END DO
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_vf(mom_idx%end)%sf(r,k,dj*((p-1)-2*j)+j) = &
flux_rs_vf(mom_idx%end)%sf(j,k,r)
END DO
END DO
END DO
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_vf(adv_idx%beg)%sf(r,k,dj*((p-1)-2*j)+j) = &
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r)
END DO
END DO
END DO
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_vf(i)%sf(r,k,dj*((p-1)-2*j)+j) = &
flux_src_rs_vf(i)%sf(j,k,r)
END DO
END DO
END DO
END DO
ELSE
DO r = ix%beg, ix%end
DO k = iy%beg, iy%end
DO j = -1, buff_size
flux_src_vf(adv_idx%beg)%sf(r,k,dj*((p-1)-2*j)+j) = &
flux_src_rs_vf(adv_idx%beg)%sf(j,k,r) * &
SIGN(1d0,-REAL(cbc_loc,KIND(0d0)))
END DO
END DO
END DO
END IF
END IF
! END: Reshaping Outputted Data in z-direction =====================
! Deallocation/Disassociation of Primitive and Flux Variables ======
DO i = 1, sys_size
DEALLOCATE(q_prim_rs_vf(i)%sf)
END DO
IF(weno_order > 1) THEN
DO i = 1, adv_idx%end
DEALLOCATE(F_rs_vf(i)%sf)
END DO
DEALLOCATE(F_src_rs_vf(adv_idx%beg)%sf)
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
DEALLOCATE(F_src_rs_vf(i)%sf)
END DO
ELSE
DO i = adv_idx%beg+1, adv_idx%end
NULLIFY(F_src_rs_vf(i)%sf)
END DO
END IF
END IF
DO i = 1, adv_idx%end
DEALLOCATE(flux_rs_vf(i)%sf)
END DO
DEALLOCATE(flux_src_rs_vf(adv_idx%beg)%sf)
IF(riemann_solver == 1) THEN
DO i = adv_idx%beg+1, adv_idx%end
DEALLOCATE(flux_src_rs_vf(i)%sf)
END DO
ELSE
DO i = adv_idx%beg+1, adv_idx%end
NULLIFY(flux_src_rs_vf(i)%sf)
END DO
END IF
! ==================================================================
! Nullifying procedural pointer used in evaluation of L for the CBC
s_compute_L => NULL()
END SUBROUTINE s_finalize_cbc ! ----------------------------------------
!> Module deallocation and/or disassociation procedures
SUBROUTINE s_finalize_cbc_module() ! -----------------------------------
IF( ALL((/bc_x%beg,bc_x%end/) > -5) &
.AND. &
(n > 0 .AND. ALL((/bc_y%beg,bc_y%end/) > -5)) &
.AND. &
(p > 0 .AND. ALL((/bc_z%beg,bc_z%end/) > -5)) ) RETURN
! Deallocating the cell-average primitive variables
DEALLOCATE(q_prim_rs_vf)
! Deallocating the cell-average and cell-boundary-average fluxes
DEALLOCATE( F_rs_vf, F_src_rs_vf)
DEALLOCATE(flux_rs_vf, flux_src_rs_vf)
! Deallocating the cell-average partial densities, the velocity, the
! advection variables, the mass fractions and also the Weber numbers
DEALLOCATE(alpha_rho, vel, adv, mf, We)
! Deallocating the first-order spatial derivatives, in s-direction,
! of the partial densities, the velocity and the advected variables
DEALLOCATE(dalpha_rho_ds, dvel_ds, dadv_ds)
! Deallocating L, see Thompson (1987, 1990)
DEALLOCATE(L)
! Deallocating the cell-width distribution in the s-direction
DEALLOCATE(ds)
! Deallocating CBC Coefficients in x-direction =====================
IF(ANY((/bc_x%beg,bc_x%end/) <= -5)) THEN
DEALLOCATE(fd_coef_x); IF(weno_order > 1) DEALLOCATE(pi_coef_x)
END IF
! ==================================================================
! Deallocating CBC Coefficients in y-direction =====================
IF(n > 0 .AND. ANY((/bc_y%beg,bc_y%end/) <= -5)) THEN
DEALLOCATE(fd_coef_y); IF(weno_order > 1) DEALLOCATE(pi_coef_y)
END IF
! ==================================================================
! Deallocating CBC Coefficients in z-direction =====================
IF(p > 0 .AND. ANY((/bc_z%beg,bc_z%end/) <= -5)) THEN
DEALLOCATE(fd_coef_z); IF(weno_order > 1) DEALLOCATE(pi_coef_z)
END IF
! ==================================================================
! Disassociating the pointer to the procedure that was utilized to
! to convert mixture or species variables to the mixture variables
s_convert_to_mixture_variables => NULL()
END SUBROUTINE s_finalize_cbc_module ! ---------------------------------
END MODULE m_cbc
|
printstyled(stdout," show\n", color=:light_green)
# SeisChannel show
S = SeisData()
C = randSeisChannel()
C.fs = 100.0
nx = (1, 2, 3, 4, 5, 10, 100, 10000)
C.t = Array{Int64,2}(undef, 0, 2)
C.x = Float32[]
push!(S, C)
redirect_stdout(out) do
for i in nx
C.t = [1 0; i 0]
C.x = randn(Float32, i)
show(C)
push!(S, C)
end
show(S)
end
redirect_stdout(out) do
# show
show(breaking_seis())
show(randSeisData(1))
show(SeisChannel())
show(SeisData())
show(randSeisChannel())
show(randSeisData(10, c=1.0))
# summary
summary(randSeisChannel())
summary(randSeisData())
# invoke help-only functions
seed_support()
mseed_support()
dataless_support()
resp_wont_read()
@test web_chanspec() == nothing
end
|
module ReverseVec
import Data.Nat
import Data.Vect
%default total
myReverse : Vect n elem -> Vect n elem
myReverse [] = []
myReverse { n = S k } (x :: xs) = let rev = myReverse xs ++ [x] in
rewrite plusCommutative 1 k in rev
ourReverse : Vect n elem -> Vect n elem
ourReverse [] = []
ourReverse (x :: xs) = reverseProof (ourReverse xs ++ [x]) where
reverseProof : Vect (len + 1) elem -> Vect (S len) elem
reverseProof { len } xs = rewrite plusCommutative 1 len in xs
|
Basic Moving is a nationwide moving company, providing quality and efficient solutions for your domestic and office moving needs at competitive rates. Bay Area Movers, Inc. is a full service moving company with local service areas which include Houston, Clear Lake, Pearland, Friendswood, Alvin, Galveston and all surrounding areas. They also move anywhere in Texas as well as nationwide.
Supported by a vast fleet of modern trucks, Best Brothers Moving specializes in moving services in California, Utah, Wisconsin and New York areas since the foundation in 2006. Best Deal Moving Co. is ready to help you whether you're moving only a few items or a large residence, a small or a big office, your move is just around the corner or across the state.
Best Move is a family owned business dedicated to assisting you and working one on one with each customer in order to provide you with the quality moving services. Headquartered in Brighton, Massachusetts, Best Movers, Inc. offers a full line of moving and packing services to meet their customersβ moving needs.
Established almost 65 years ago, Best Value Move is family owned business which operating in Flower Mound,Texas and also has offices in Dallas and San Antonio. Since 2004, Big Mountain Movers strives to provide professional full service moves, serving the entire state of Utah and all across the United States. |
theory RelyGuarantee
imports Language
begin
datatype ('a, 'b) stmt =
Atom 'a
| Choice "('a, 'b) stmt" "('a, 'b) stmt"
| Seq "('a, 'b) stmt" "('a, 'b) stmt" (infixr ";" 60)
| Par "('a, 'b) stmt" "('a, 'b) stmt"
| Star "('a, 'b) stmt"
| Fail
| Skip
datatype 'a act = Act "'a \<Rightarrow> 'a set"
primrec runAct :: "'a act \<Rightarrow> 'a \<Rightarrow> 'a set" where
"runAct (Act f) = f"
lemma st_ext [intro]: "(\<And>x. runAct f x = runAct g x) \<Longrightarrow> f = g"
apply (rule act.exhaust[of f])
apply (rule act.exhaust[of g])
by auto
instantiation act :: (type) monoid_add
begin
definition zero_act :: "'a act" where
"zero_act = Act (\<lambda>x. {x})"
definition plus_act :: "'a act \<Rightarrow> 'a act \<Rightarrow> 'a act" where
"plus_act f g \<equiv> Act (\<lambda>\<sigma>. \<Union>{runAct g \<sigma>'|\<sigma>'. \<sigma>' \<in> runAct f \<sigma>})"
instance
apply default
apply (simp_all add: zero_act_def plus_act_def)
apply (rule ext)
apply auto
apply (rule st_ext)
by auto
end
primrec semantics :: "('a \<Rightarrow> 'b act) \<Rightarrow> ('a, 'b) stmt \<Rightarrow> 'b act lan" where
"semantics f (Atom a) = {f a # []}"
| "semantics f (Choice x y) = semantics f x \<union> semantics f y"
| "semantics f (Seq x y) = semantics f x \<cdot> semantics f y"
| "semantics f (Par x y) = semantics f x \<parallel> semantics f y"
| "semantics f (Star x) = (semantics f x)\<^sup>*"
| "semantics f Fail = {}"
| "semantics f Skip = {[]}"
definition eval_word :: "'a act list \<Rightarrow> 'a set \<Rightarrow> 'a set" where
"eval_word xs H = \<Union>{runAct (listsum xs) h|h. h \<in> H}"
lemma eval_empty_word [simp]: "eval_word [] h = h"
by (auto simp add: eval_word_def zero_act_def)
lemma eval_cons_word [simp]: "eval_word (x # xs) h = eval_word xs (\<Union>runAct x ` h)"
by (auto simp add: eval_word_def plus_act_def)
lemma eval_append_word: "eval_word (xs @ ys) h = eval_word ys (eval_word xs h)"
by (induct xs arbitrary: h) simp_all
definition module :: "'a act lan \<Rightarrow> 'a set \<Rightarrow> 'a set" (infix "\<Colon>" 60) where
"x \<Colon> h \<equiv> \<Union>{eval_word w h|w. w \<in> x}"
lemma eval_word_continuous: "eval_word w (\<Union>X) = \<Union>eval_word w ` X"
by (induct w arbitrary: X) (auto simp add: image_def)
lemma mod_mult: "x\<cdot>y \<Colon> h = y \<Colon> (x \<Colon> h)"
proof -
have "x\<cdot>y \<Colon> h = \<Union>{eval_word w h|w. w \<in> x\<cdot>y}"
by (simp add: module_def)
also have "... = \<Union>{eval_word (xw @ yw) h|xw yw. xw \<in> x \<and> yw \<in> y}"
by (auto simp add: l_prod_def complex_product_def)
also have "... = \<Union>{eval_word yw (eval_word xw h)|xw yw. xw \<in> x \<and> yw \<in> y}"
by (simp add: eval_append_word)
also have "... = \<Union>{\<Union>{eval_word yw (eval_word xw h)|xw. xw \<in> x}|yw. yw \<in> y}"
by blast
also have "... = \<Union>{eval_word yw (\<Union>{eval_word xw h|xw. xw \<in> x})|yw. yw \<in> y}"
by (subst eval_word_continuous) (auto simp add: image_def)
also have "... = \<Union>{eval_word yw (x \<Colon> h)|yw. yw \<in> y}"
by (simp add: module_def)
also have "... = y \<Colon> (x \<Colon> h)"
by (simp add: module_def)
finally show ?thesis .
qed
lemma mod_one [simp]: "{[]} \<Colon> h = h"
by (simp add: module_def)
lemma mod_zero [simp]: "{} \<Colon> h = {}"
by (simp add: module_def)
lemma mod_empty [simp]: "x \<Colon> {} = {}"
by (simp add: module_def eval_word_def)
lemma mod_distl: "(x \<union> y) \<Colon> h = (x \<Colon> h) \<union> (y \<Colon> h)"
proof -
have "(x \<union> y) \<Colon> h = \<Union>{eval_word w h|w. w \<in> x \<union> y}"
by (simp add: module_def)
also have "... = \<Union>{eval_word w h|w. w \<in> x \<or> w \<in> y}"
by blast
also have "... = \<Union>{eval_word w h|w. w \<in> x} \<union> \<Union>{eval_word w h|w. w \<in> y}"
by blast
also have "... = (x \<Colon> h) \<union> (y \<Colon> h)"
by (simp add: module_def)
finally show ?thesis .
qed
lemma mod_distr: "x \<Colon> (h \<union> g) = (x \<Colon> h) \<union> (x \<Colon> g)"
proof -
have "x \<Colon> (h \<union> g) = \<Union>{eval_word w (h \<union> g)|w. w \<in> x}"
by (simp add: module_def)
also have "... = \<Union>{eval_word w h \<union> eval_word w g|w. w \<in> x}"
by (simp add: eval_word_def) blast
also have "... = \<Union>{eval_word w h|w. w \<in> x} \<union> \<Union>{eval_word w g|w. w \<in> x}"
by blast
also have "... = (x \<Colon> h) \<union> (x \<Colon> g)"
by (simp add: module_def)
finally show ?thesis .
qed
lemma mod_isol: "x \<subseteq> y \<Longrightarrow> x \<Colon> p \<subseteq> y \<Colon> p"
by (auto simp add: module_def)
lemma mod_isor: "p \<subseteq> q \<Longrightarrow> x \<Colon> p \<subseteq> x \<Colon> q"
by (metis mod_distr subset_Un_eq)
lemma mod_continuous: "\<Union>X \<Colon> p = \<Union>{x \<Colon> p|x. x \<in> X}"
by (simp add: module_def) blast
lemma mod_continuous_var: "\<Union>{f x|x. P x} \<Colon> p = \<Union>{f x \<Colon> p|x. P x}"
by (simp add: mod_continuous) blast
definition mod_test :: "('a set) \<Rightarrow> 'a act lan" ("_?" [101] 100) where
"p? \<equiv> {[Act (\<lambda>x. {x} \<inter> p)]}"
lemma mod_test: "p? \<Colon> q = p \<inter> q"
by (auto simp add: module_def mod_test_def)
lemma test_true: "q \<subseteq> p \<Longrightarrow> p? \<Colon> q = q"
by (metis Int_absorb1 mod_test)
lemma test_false: "q \<subseteq> -p \<Longrightarrow> p? \<Colon> q = {}"
by (metis Int_commute disjoint_eq_subset_Compl mod_test)
lemma l_prod_distr: "(X \<union> Y) \<cdot> Z = X \<cdot> Z \<union> Y \<cdot> Z"
by (insert l_prod_inf_distr[of "{X, Y}" Z]) auto
lemma l_prod_distl: "X \<cdot> (Y \<union> Z) = X \<cdot> Y \<union> X \<cdot> Z"
by (insert l_prod_inf_distl[of "X" "{Y, Z}"]) auto
no_notation
Transitive_Closure.trancl ("(_\<^sup>+)" [1000] 999)
definition l_plus :: "'a lan \<Rightarrow> 'a lan" ("_\<^sup>+" [101] 100) where
"X\<^sup>+ = X\<cdot>X\<^sup>*"
lemma l_plus_unfold: "X\<^sup>+ = X \<union> X\<^sup>+"
sorry
lemma "q \<subseteq> p \<Longrightarrow> (p?)\<^sup>+\<cdot>x \<Colon> q = (x \<Colon> q) \<union> ((p?)\<^sup>+\<cdot>x \<Colon> q)"
by (smt l_plus_unfold l_prod_distr mod_distl mod_mult test_true)
lemma "(p?)\<^sup>+\<cdot>x \<Colon> q = (x \<Colon> q \<inter> p) \<union> ((p?)\<^sup>+\<cdot>x \<Colon> q)"
by (metis inf.commute l_plus_unfold mod_distl mod_distr mod_mult mod_test)
lemma "q \<subseteq> p \<Longrightarrow> (p?)\<^sup>+\<cdot>x \<Colon> q = (x \<Colon> q)"
nitpick
lemma "p?\<cdot>x \<Colon> q = x\<cdot>q"
lemma "q \<subseteq> -p \<Longrightarrow> p? \<Colon> q = {}"
by (metis Int_commute disjoint_eq_subset_Compl mod_test)
lemma image_InL [simp]: "map \<langle>id,id\<rangle> ` op # (InL x) ` X = op # x ` map \<langle>id,id\<rangle> ` X"
by (auto simp add: image_def)
lemma image_InR [simp]: "map \<langle>id,id\<rangle> ` op # (InR x) ` X = op # x ` map \<langle>id,id\<rangle> ` X"
by (auto simp add: image_def)
lemma image_singleton: "op # x ` X = {[x]} \<cdot> X"
by (auto simp add: image_def l_prod_def complex_product_def)
lemma tshuffle_await_cons:
"q \<subseteq> - p \<Longrightarrow> map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # ys) \<sha> (x # xs)) \<Colon> q = op # x ` (map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # ys) \<sha> xs)) \<Colon> q"
apply (subst tshuffle_ind)
apply (simp add: mod_distl)
apply (simp add: image_singleton mod_mult)
apply (subst module_def) back
apply (subgoal_tac "q \<inter> p = {}")
apply simp
by blast
definition to_rel :: "('a \<Rightarrow> 'a set) \<Rightarrow> 'a rel" where
"to_rel f = {(x, y)|x y. y \<in> f x}"
definition to_fun :: "'a rel \<Rightarrow> 'a \<Rightarrow> 'a set" where
"to_fun R x = {y. (x, y) \<in> R}"
lemma rel_fun_inv [simp]: "to_rel (to_fun R) = R"
by (auto simp add: to_fun_def to_rel_def)
lemma fun_rel_inv [simp]: "to_fun (to_rel f) = f"
by (auto simp add: to_fun_def to_rel_def)
lemma [simp]: "to_fun {} = (\<lambda>x. {})"
apply (rule ext)
by (simp add: to_fun_def)
definition \<iota> :: "'a act lan \<Rightarrow> 'a rel" where
"\<iota> X = \<Union>{to_rel (runAct x)|x. x \<in> symbols X}"
definition \<rho> :: "'a rel \<Rightarrow> 'a act lan" where
"\<rho> R = pow_inv {Act (to_fun S)|S. S \<subseteq> R}"
lemma \<iota>_iso: "X \<subseteq> Y \<Longrightarrow> \<iota> X \<subseteq> \<iota> Y"
apply (simp add: \<iota>_def symbols_def)
by blast
lemma \<rho>_iso: "X \<subseteq> Y \<Longrightarrow> \<rho> X \<subseteq> \<rho> Y"
apply (simp add: \<rho>_def)
apply (rule pow_inv_iso)
by blast
lemma [simp]: "symbols (pow_inv Z) = Z"
proof -
{
fix x
assume "x \<in> Z"
hence "[x] \<in> pow_inv Z"
by (metis pow_inv.pinv_cons pow_inv.pinv_empty)
hence "x \<in> symbols (pow_inv Z)"
by (metis symbol_cons)
}
moreover
have "symbols (pow_inv Z) \<subseteq> Z"
proof (auto simp add: symbols_def)
fix x xs
assume "xs \<in> pow_inv Z" and "x \<in> set xs"
thus "x \<in> Z"
by (induct xs rule: pow_inv.induct) auto
qed
ultimately show ?thesis
by auto
qed
lemma [simp]: "\<Union>{to_rel (runAct xa)|xa. \<exists>S. xa = Act (to_fun S) \<and> S \<subseteq> x} = \<Union>{S|S. S \<subseteq> x}"
apply (rule arg_cong) back
apply auto
apply (rule_tac x = "Act (to_fun xa)" in exI)
apply simp
apply (rule_tac x = "xa" in exI)
by auto
lemma \<iota>_\<rho>_eq: "\<iota> (\<rho> x) = x"
by (simp add: \<iota>_def \<rho>_def, auto)
lemma \<rho>_\<iota>_eq: "x \<subseteq> \<rho> (\<iota> x)"
apply (simp add: \<iota>_def \<rho>_def)
apply (rule order_trans[of _ "pow_inv (symbols x)"])
apply (metis inv_sym_extensive)
apply (rule pow_inv_iso)
apply auto
apply (rule_tac x = "to_rel (runAct xa)" in exI)
by auto
lemma galois_connection: "\<iota> x \<subseteq> y \<longleftrightarrow> x \<subseteq> \<rho> y"
apply default
apply (metis \<rho>_\<iota>_eq \<rho>_iso subset_trans)
by (metis \<iota>_\<rho>_eq \<iota>_iso)
definition "preserves b \<equiv> {(\<sigma>,\<sigma>'). \<sigma> \<in> b \<longrightarrow> \<sigma>' \<in> b}"
lemma \<iota>_tl: "\<iota> {x # xs} \<subseteq> preserves p \<Longrightarrow> \<iota> {xs} \<subseteq> preserves p"
by (auto simp add: preserves_def \<iota>_def symbols_def)
lemma \<iota>_hd: "\<iota> {x # xs} \<subseteq> preserves p \<Longrightarrow> \<iota> {[x]} \<subseteq> preserves p"
by (auto simp add: preserves_def \<iota>_def symbols_def)
lemma \<iota>_member: "\<iota> x \<subseteq> preserves p \<Longrightarrow> xw \<in> x \<Longrightarrow> \<iota> {xw} \<subseteq> preserves p"
by (auto simp add: preserves_def \<iota>_def symbols_def Sup_le_iff)
lemma \<iota>_singleton_preserves: "\<iota> {[x]} \<subseteq> preserves p \<longleftrightarrow> (\<forall>q. q \<subseteq> p \<longrightarrow> {[x]} \<Colon> q \<subseteq> p)"
by (auto simp add: preserves_def module_def \<iota>_def symbols_def to_rel_def)
lemma tshuffle_await_append:
"\<iota> {xs} \<subseteq> preserves (- p) \<Longrightarrow>
q \<subseteq> -p \<Longrightarrow>
map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> (xs @ ys)) \<Colon> q = op @ xs ` (map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> ys)) \<Colon> q"
proof (induct xs arbitrary: q)
case Nil
show ?case by simp
next
case (Cons x xs)
assume ih: "\<And>q. \<iota> {xs} \<subseteq> preserves (- p) \<Longrightarrow>
q \<subseteq> - p \<Longrightarrow>
map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> (xs @ ys)) \<Colon> q = op @ xs ` map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> ys) \<Colon> q"
and x_xs_preserves_not_p: "\<iota> {x # xs} \<subseteq> preserves (- p)"
and not_p: "q \<subseteq> - p"
hence not_p': "{[x]} \<Colon> q \<subseteq> -p"
by (metis (hide_lams, no_types) \<iota>_hd \<iota>_singleton_preserves)
have "map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> ((x # xs) @ ys)) \<Colon> q = map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> (x # xs @ ys)) \<Colon> q"
by simp
also have "... = op # x ` map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> (xs @ ys)) \<Colon> q"
by (simp only: tshuffle_await_cons[OF not_p])
also have "... = map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> (xs @ ys)) \<Colon> ({[x]} \<Colon> q)"
by (simp only: image_singleton mod_mult)
also have "... = op @ xs ` map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> ys) \<Colon> ({[x]} \<Colon> q)"
by (simp only: ih[OF \<iota>_tl[OF x_xs_preserves_not_p] not_p'])
also have "... = op # x ` op @ xs ` map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> ys) \<Colon> q"
by (simp only: mod_mult[symmetric] image_singleton[symmetric])
also have "... = op @ (x # xs) ` map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zs) \<sha> ys) \<Colon> q"
by (simp only: image_compose[symmetric] o_def append.simps)
finally show ?case .
qed
lemma set_comp_3_eq: "(\<And>x y z. Q x y z \<Longrightarrow> P x y z = P' x y z) \<Longrightarrow> {P x y z|x y z. Q x y z} = {P' x y z|x y z. Q x y z}"
by auto metis+
lemma helper: "\<Union>{{xw} \<cdot> P y z|y xw z. Q y z \<and> xw \<in> x \<and> Q y z} = \<Union>{x \<cdot> P y z|y z. Q y z}"
by (auto simp add: l_prod_def complex_product_def)
lemma image_append: "op @ xs ` X = {xs} \<cdot> X"
by (auto simp add: l_prod_def complex_product_def)
lemma await_par:
assumes x_preserves_not_p: "\<iota> x \<subseteq> preserves (- p)"
and not_p: "q \<subseteq> -p"
shows "p?\<cdot>z \<parallel> x\<cdot>y \<Colon> q = x\<cdot>(p?\<cdot>z \<parallel> y) \<Colon> q"
proof -
have "p?\<cdot>z \<parallel> x\<cdot>y \<Colon> q = \<Union>{map \<langle>id,id\<rangle> ` (pzw \<sha> xyw)|pzw xyw. pzw \<in> p? \<cdot> z \<and> xyw \<in> x \<cdot> y} \<Colon> q"
by (simp add: shuffle_def)
also have "... = \<Union>{map \<langle>id,id\<rangle> ` (pzw \<sha> xyw) \<Colon> q|pzw xyw. pzw \<in> p? \<cdot> z \<and> xyw \<in> x \<cdot> y}"
by (subst mod_continuous) blast
also have "... = \<Union>{map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zw) \<sha> (xw @ yw)) \<Colon> q|zw xw yw. zw \<in> z \<and> xw \<in> x \<and> yw \<in> y}"
by (simp add: l_prod_def complex_product_def mod_test_def, rule arg_cong, blast)
also have "... = \<Union>{op @ xw ` map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zw) \<sha> yw) \<Colon> q|zw xw yw. zw \<in> z \<and> xw \<in> x \<and> yw \<in> y}"
apply (rule arg_cong) back
apply (rule set_comp_3_eq)
apply (subst tshuffle_await_append)
apply (metis \<iota>_member x_preserves_not_p)
apply (metis not_p)
by simp
also have "... = \<Union>{op @ xw ` map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zw) \<sha> yw)|zw xw yw. zw \<in> z \<and> xw \<in> x \<and> yw \<in> y} \<Colon> q"
by (subst mod_continuous) blast
also have "... = \<Union>{{xw} \<cdot> map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zw) \<sha> yw)|zw xw yw. zw \<in> z \<and> xw \<in> x \<and> yw \<in> y} \<Colon> q"
by (simp only: image_append)
also have "... = \<Union>{x \<cdot> map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zw) \<sha> yw)|zw yw. zw \<in> z \<and> yw \<in> y} \<Colon> q"
by (rule arg_cong, auto simp add: l_prod_def complex_product_def)
also have "... = x \<cdot> \<Union>{map \<langle>id,id\<rangle> ` ((Act (\<lambda>x. {x} \<inter> p) # zw) \<sha> yw)|zw yw. zw \<in> z \<and> yw \<in> y} \<Colon> q"
by (subst l_prod_inf_distl, rule arg_cong, blast)
also have "... = x \<cdot> \<Union>{map \<langle>id,id\<rangle> ` (pzw \<sha> yw)|pzw yw. pzw \<in> p? \<cdot> z \<and> yw \<in> y} \<Colon> q"
by (simp add: l_prod_def complex_product_def mod_test_def, rule arg_cong, blast)
also have "... = x\<cdot>(p?\<cdot>z \<parallel> y) \<Colon> q"
by (simp add: shuffle_def)
finally show ?thesis .
qed
(*
primrec splittings_ind :: "'a list \<Rightarrow> 'a list \<Rightarrow> ('a list \<times> 'a list) set" where
"splittings_ind ys [] = {(ys, [])}"
| "splittings_ind ys (x#xs) = {(ys, x#xs)} \<union> (splittings_ind (ys @ [x]) xs)"
definition splittings where "splittings xs = {(ys,zs). ys @ zs = xs}"
definition add_first where "add_first xs X = (\<lambda>x. (xs @ fst x, snd x)) ` X"
lemma afs: "add_first ws (splittings xs) = {(ws @ ys,zs)|ys zs. ys @ zs = xs}"
by (auto simp add: add_first_def splittings_def image_def)
lemma l1: "splittings_ind ys xs = add_first ys (splittings xs)"
apply (simp add: afs)
apply (induct xs arbitrary: ys)
apply simp
apply auto
apply (metis Cons_eq_append_conv)
by (metis (hide_lams, no_types) append_eq_Cons_conv)
lemma [simp]: "add_first [] (splittings xs) = splittings xs"
by (simp add: splittings_def add_first_def)
lemma l2: "splittings_ind [] xs = splittings xs"
by (insert l1[of "[]"], simp)
*)
type_synonym mem = "nat \<Rightarrow> nat option"
datatype atoms =
Assign nat nat
| Pred "mem set"
primrec atoms_interp :: "atoms \<Rightarrow> mem act" where
"atoms_interp (Assign x v) = Act (\<lambda>mem. {\<lambda>y. if x = y then Some v else mem y})"
| "atoms_interp (Pred p) = Act (\<lambda>mem. if mem \<in> p then {mem} else {})"
definition domain :: "mem \<Rightarrow> nat set" where
"domain f \<equiv> {x. f x \<noteq> None}"
definition disjoint :: "mem \<Rightarrow> mem \<Rightarrow> bool" where
"disjoint f g \<equiv> domain f \<inter> domain g = {}"
definition merge :: "mem \<Rightarrow> mem \<Rightarrow> mem" where
"merge \<sigma> \<sigma>' = (\<lambda>v. if \<sigma> v = None then \<sigma>' v else \<sigma> v)"
definition sep_conj :: "mem set \<Rightarrow> mem set \<Rightarrow> mem set" (infixr "**" 45) where
"p ** q \<equiv> {\<sigma>''. \<exists>\<sigma> \<sigma>'. disjoint \<sigma> \<sigma>' \<and> \<sigma>'' = merge \<sigma> \<sigma>' \<and> \<sigma> \<in> p \<and> \<sigma>' \<in> q}"
definition quintuple :: "'b rel \<Rightarrow> 'b rel \<Rightarrow> ('a \<Rightarrow> 'b act) \<Rightarrow> 'b set \<Rightarrow> ('a, 'b) stmt \<Rightarrow> 'b set \<Rightarrow> bool"
("_, _ \<turnstile>\<^bsub>_\<^esub> \<lbrace>_\<rbrace> _ \<lbrace>_\<rbrace>" [20,20,0,20,20,20] 100) where
"r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> c \<lbrace>q\<rbrace> \<equiv> (\<rho> r \<parallel> semantics \<Gamma> c \<Colon> p \<subseteq> q) \<and> (\<iota> (semantics \<Gamma> c) \<subseteq> g)"
definition stable :: "'b rel \<Rightarrow> 'b set \<Rightarrow> bool" where
"stable r p \<equiv> \<rho> r \<Colon> p \<subseteq> p"
lemma SKIP: "stable r p \<Longrightarrow> r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> Skip \<lbrace>p\<rbrace>"
by (simp add: quintuple_def \<iota>_def symbols_def stable_def)
lemma inv_exchange: "\<rho> r \<parallel> x \<cdot> y = (\<rho> r \<parallel> x) \<cdot> (\<rho> r \<parallel> y)"
sorry
lemma inv_join: "\<iota>(x \<parallel> y) = \<iota> x \<union> \<iota> y"
sorry
lemma SEQ:
assumes "r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> C1 \<lbrace>q\<rbrace>" and "r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>q\<rbrace> C2 \<lbrace>s\<rbrace>"
shows "r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> C1; C2 \<lbrace>s\<rbrace>"
using assms
apply (simp add: quintuple_def inv_exchange mod_mult)
apply (intro conjI)
apply (metis mod_isor order_trans)
by (metis Un_upper2 \<iota>_iso empty_subsetI inv_join shuffle_zerol subset_antisym)
lemma rely_dup: "\<rho> r = \<rho> r \<parallel> \<rho> r"
by (metis (full_types) \<iota>_\<rho>_eq empty_subsetI galois_connection inv_join inv_shuffle inv_sym_extensive shuffle_zeror sup_top_left top_unique)
lemma shuffle_isor: "X \<subseteq> Y \<Longrightarrow> Z \<parallel> X \<subseteq> Z \<parallel> Y"
by (metis shuffle_comm shuffle_iso)
lemma PAR:
assumes "g1 \<subseteq> r2" and "r1, g1 \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p1\<rbrace> C1 \<lbrace>q1\<rbrace>"
and "g2 \<subseteq> r1" and "r2, g2 \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p2\<rbrace> C2 \<lbrace>q2\<rbrace>"
shows "(r1 \<inter> r2), (g1 \<union> g2) \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p1 \<inter> p2\<rbrace> Par C1 C2 \<lbrace>q1 \<inter> q2\<rbrace>"
proof (simp add: quintuple_def, intro conjI)
let ?c1 = "semantics \<Gamma> C1"
let ?c2 = "semantics \<Gamma> C2"
have "\<rho> (r1 \<inter> r2) \<parallel> (?c1 \<parallel> ?c2) \<Colon> p1 \<inter> p2 = (\<rho> (r1 \<inter> r2) \<parallel> ?c1) \<parallel> (\<rho> (r1 \<inter> r2) \<parallel> ?c2) \<Colon> p1 \<inter> p2"
by (smt rely_dup shuffle_assoc shuffle_comm)
also have "... \<subseteq> (\<rho> (r1 \<inter> r2) \<parallel> ?c1) \<parallel> (\<rho> (r1 \<inter> r2) \<parallel> ?c2) \<Colon> p1"
by (metis Int_lower1 mod_isor)
also have "... \<subseteq> (\<rho> (r1 \<inter> r2) \<parallel> ?c1) \<parallel> (\<rho> (r1 \<inter> r2) \<parallel> \<rho> (\<iota> ?c2)) \<Colon> p1"
by (intro mod_isol shuffle_isor) (metis \<rho>_\<iota>_eq)
also have "... \<subseteq> (\<rho> (r1 \<inter> r2) \<parallel> ?c1) \<parallel> (\<rho> (r1 \<inter> r2) \<parallel> \<rho> g2) \<Colon> p1"
by (intro mod_isol shuffle_isor) (metis \<rho>_iso assms(4) quintuple_def)
also have "... \<subseteq> (\<rho> (r1 \<inter> r2) \<parallel> ?c1) \<parallel> \<rho> (r1 \<inter> r2) \<Colon> p1"
by (intro mod_isol shuffle_isor) (metis empty_subsetI galois_connection inf_absorb2 inv_join le_inf_iff shuffle_zeror sup_ge1)
also have "... \<subseteq> (\<rho> r1 \<parallel> ?c1) \<parallel> \<rho> r1 \<Colon> p1"
by (metis \<iota>_\<rho>_eq galois_connection inf_le1 mod_isol rely_dup shuffle_assoc shuffle_comm shuffle_iso)
also have "... = \<rho> r1 \<parallel> ?c1 \<Colon> p1"
by (metis rely_dup shuffle_assoc shuffle_comm)
also have "... \<subseteq> q1"
by (metis assms(2) quintuple_def)
finally show "\<rho> (r1 \<inter> r2) \<parallel> (semantics \<Gamma> C1 \<parallel> semantics \<Gamma> C2) \<Colon> p1 \<inter> p2 \<subseteq> q1" .
have "\<rho> (r1 \<inter> r2) \<parallel> (?c1 \<parallel> ?c2) \<Colon> p1 \<inter> p2 = \<rho> (r1 \<inter> r2) \<parallel> (?c2 \<parallel> ?c1) \<Colon> p1 \<inter> p2"
by (metis shuffle_comm)
also have "... = (\<rho> (r1 \<inter> r2) \<parallel> ?c2) \<parallel> (\<rho> (r1 \<inter> r2) \<parallel> ?c1) \<Colon> p1 \<inter> p2"
by (smt rely_dup shuffle_assoc shuffle_comm)
also have "... \<subseteq> (\<rho> (r1 \<inter> r2) \<parallel> ?c2) \<parallel> (\<rho> (r1 \<inter> r2) \<parallel> ?c1) \<Colon> p2"
by (metis Int_lower2 mod_isor)
also have "... \<subseteq> (\<rho> (r1 \<inter> r2) \<parallel> ?c2) \<parallel> (\<rho> (r1 \<inter> r2) \<parallel> \<rho> (\<iota> ?c1)) \<Colon> p2"
by (intro mod_isol shuffle_isor) (metis \<rho>_\<iota>_eq)
also have "... \<subseteq> (\<rho> (r1 \<inter> r2) \<parallel> ?c2) \<parallel> (\<rho> (r1 \<inter> r2) \<parallel> \<rho> g1) \<Colon> p2"
by (intro mod_isol shuffle_isor) (metis \<rho>_iso assms(2) quintuple_def)
also have "... \<subseteq> (\<rho> (r1 \<inter> r2) \<parallel> ?c2) \<parallel> \<rho> (r1 \<inter> r2) \<Colon> p2"
by (intro mod_isol shuffle_isor) (metis empty_subsetI galois_connection inf_absorb2 inv_join shuffle_zeror sup_inf_absorb)
also have "... \<subseteq> (\<rho> r2 \<parallel> ?c2) \<parallel> \<rho> r2 \<Colon> p2"
by (metis \<rho>_iso inf_le2 mod_isol rely_dup shuffle_assoc shuffle_comm shuffle_iso)
also have "... = \<rho> r2 \<parallel> ?c2 \<Colon> p2"
by (metis rely_dup shuffle_assoc shuffle_comm)
also have "... \<subseteq> q2"
by (metis assms(4) quintuple_def)
finally show "\<rho> (r1 \<inter> r2) \<parallel> (semantics \<Gamma> C1 \<parallel> semantics \<Gamma> C2) \<Colon> p1 \<inter> p2 \<subseteq> q2" .
show "\<iota> (?c1 \<parallel> ?c2) \<subseteq> g1 \<union> g2"
by (metis assms(2) assms(4) inv_join quintuple_def sup_mono)
qed
lemma CHOICE:
assumes "r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> C1 \<lbrace>q\<rbrace>" and "r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> C2 \<lbrace>q\<rbrace>"
shows "r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> Choice C1 C2 \<lbrace>q\<rbrace>"
using assms
apply (simp add: quintuple_def)
apply (intro conjI)
apply (metis le_sup_iff mod_distl shuffle_distl)
by (metis galois_connection le_sup_iff)
definition Await :: "mem set \<Rightarrow> (atoms, mem) stmt \<Rightarrow> (atoms, mem) stmt" where
"Await b C = Seq (Atom (Pred b)) C"
lemma helper2: "x \<subseteq> y \<Longrightarrow> y \<union> z \<subseteq> w \<Longrightarrow> x \<union> z \<subseteq> w"
by (metis le_sup_iff order_trans)
lemma helper3: "x \<subseteq> y \<Longrightarrow> x \<union> y \<subseteq> y"
by (metis le_sup_iff order_refl)
lemma test: "{(\<sigma>, \<sigma>'). \<sigma>' \<in> runAct a \<sigma>} \<subseteq> {(\<sigma>, \<sigma>'). \<sigma> \<in> p \<longrightarrow> \<sigma>' \<in> p} \<Longrightarrow> \<sigma> \<in> p \<longrightarrow> runAct a \<sigma> \<subseteq> p"
by auto
lemma test_comm: "\<iota> {[x]} \<subseteq> preserves p \<Longrightarrow> {[Act (\<lambda>x. {x} \<inter> p)]} \<cdot> {[x]} \<Colon> q \<subseteq> {[x]} \<cdot> {[Act (\<lambda>x. {x} \<inter> p)]} \<Colon> q"
by (auto simp add: l_prod_def complex_product_def module_def preserves_def \<iota>_def symbols_def to_rel_def)
lemma tshuffle_left_leq: "{[x]} \<cdot> map \<langle>id,id\<rangle> ` (xs \<sha> ys) \<subseteq> map \<langle>id,id\<rangle> ` ((x # xs) \<sha> ys)"
apply (induct ys)
apply (simp add: l_prod_def complex_product_def)
apply (simp only: tshuffle_ind image_Un image_InL)
apply (simp only: image_singleton)
by (metis Un_upper1)
lemma tshuffle_right_leq: "{[y]} \<cdot> map \<langle>id,id\<rangle> ` (xs \<sha> ys) \<subseteq> map \<langle>id,id\<rangle> ` (xs \<sha> (y # ys))"
by (metis (hide_lams, no_types) tshuffle_left_leq tshuffle_words_comm)
lemma mod_isol_var: "z \<subseteq> y \<Longrightarrow> x \<Colon> p \<subseteq> z \<Colon> p \<Longrightarrow> x \<Colon> p \<subseteq> y \<Colon> p"
by (metis mod_isol subset_trans)
lemma preserve_test_tshuffle:
"\<iota> {xs} \<subseteq> preserves p \<Longrightarrow> map \<langle>id,id\<rangle> ` (xs \<sha> (Act (\<lambda>x. {x} \<inter> p) # ys)) \<Colon> q = {[Act (\<lambda>x. {x} \<inter> p)]} \<cdot> map \<langle>id,id\<rangle> ` (xs \<sha> ys) \<Colon> q"
apply default
defer
apply (rule mod_isol)
apply (rule tshuffle_right_leq)
proof (induct xs arbitrary: q)
case Nil
show ?case by (simp add: l_prod_def complex_product_def)
next
case (Cons x xs)
assume "\<And>q. \<iota> {xs} \<subseteq> preserves p \<Longrightarrow>
map \<langle>id,id\<rangle> ` (xs \<sha> (Act (\<lambda>x. {x} \<inter> p) # ys)) \<Colon> q \<subseteq> {[Act (\<lambda>x. {x} \<inter> p)]} \<cdot> map \<langle>id,id\<rangle> ` (xs \<sha> ys) \<Colon> q"
and x_xs_preserves_p: "\<iota> {x # xs} \<subseteq> preserves p"
note ih = this(1)[OF \<iota>_tl[OF this(2)]]
show ?case
apply (simp only: tshuffle_ind image_Un image_InL image_InR mod_distl)
apply (simp only: image_singleton)
apply (subst mod_mult)
apply (rule helper2[OF ih])
apply (subst mod_mult[symmetric])
apply (rule helper3)
apply (subst l_prod_assoc[symmetric])
apply (rule mod_isol_var[OF l_prod_isor[OF tshuffle_left_leq]])
apply (subst l_prod_assoc[symmetric])
apply (subst mod_mult)
apply (subst mod_mult) back
apply (rule mod_isor)
apply (subst mod_mult)
apply (subst test_comm[OF q_satisfies_p \<iota>_hd[OF x_xs_preserves_p]])
apply (subst mod_mult[symmetric])
apply (subst l_prod_assoc)
apply (rule mod_isol)
apply (rule l_prod_isor)
by (rule tshuffle_left_leq)
qed
*)
lemma preserve_test:
assumes "r \<subseteq> preserves s" and "q \<subseteq> p"
shows "(\<rho> r \<parallel> p? \<cdot> x) \<Colon> q = p? \<cdot> (\<rho> r \<parallel> x) \<Colon> q"
sorry
lemma AWAIT1: "r \<subseteq> preserves s \<Longrightarrow> p \<subseteq> s \<Longrightarrow> r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>s\<rbrace> C \<lbrace>q\<rbrace> \<Longrightarrow> r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> Await s C \<lbrace>q\<rbrace>" sorry
lemma AWAIT:
assumes "g1 \<subseteq> r2" and "r1, g1 \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p1 \<inter> t\<rbrace> C1 \<lbrace>q1\<rbrace>"
and "g2 \<subseteq> r1" and "r2, g2 \<inter> preserves t \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p2\<rbrace> C2 \<lbrace>t \<inter> q2\<rbrace>"
shows "(r1 \<inter> r2), (g1 \<union> g2) \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p1 \<inter> p2\<rbrace> Par (Await t C1) C2 \<lbrace>q1 \<inter> q2\<rbrace>"
apply (rule PAR)
sorry
lemma Sup_image_le_iff: "(\<Union>{f x|x. P x} \<subseteq> Y) \<longleftrightarrow> (\<forall>x. P x \<longrightarrow> f x \<subseteq> Y)"
by blast
lemma mod_forall: "X \<Colon> p \<subseteq> q \<longleftrightarrow> (\<forall>x\<in>X. {x} \<Colon> p \<subseteq> q)"
by (auto simp add: module_def)
lemma pow_inv_singleton: "x \<in> X \<Longrightarrow> [x] \<in> pow_inv X"
by (metis pow_inv.pinv_cons pow_inv.pinv_empty)
lemma stable_forall: "stable r p \<longleftrightarrow> (\<forall>xs\<in>(pow_inv {Act (to_fun S) |S. S \<subseteq> r}). {xs} \<Colon> p \<subseteq> p)"
apply (simp add: stable_def \<rho>_def)
apply (subst mod_forall)
by simp
lemma singleton_stable: "stable r p \<Longrightarrow> x \<in> {Act (to_fun S) |S. S \<subseteq> r} \<Longrightarrow> {[x]} \<Colon> p \<subseteq> p"
apply (simp only: stable_forall \<rho>_def)
apply (drule pow_inv_singleton)
by auto
lemma mod_cons: "op # x ` X \<Colon> p = {[x]} \<cdot> X \<Colon> p"
by (simp add: image_def complex_product_def l_prod_def, rule arg_cong, blast)
lemma [simp]: "map \<langle>id,id\<rangle> ` op # (InL x) ` X = op # x ` map \<langle>id,id\<rangle> ` X"
by (auto simp add: image_def)
lemma mod_cons_var: "{x # xs} \<Colon> p = {[x]} \<cdot> {xs} \<Colon> p"
by (auto simp add: l_prod_def complex_product_def)
lemma ATOM:
assumes atom: "\<forall>\<sigma>\<in>p. runAct (\<Gamma> a) \<sigma> \<subseteq> q"
and p_stable: "stable r p"
and q_stable: "stable r q"
shows "r, {(\<sigma>,\<sigma>'). \<sigma>' \<in> runAct (\<Gamma> a) \<sigma>} \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> Atom a \<lbrace>q\<rbrace>"
proof -
from assms have atom': "({[\<Gamma> a]} \<Colon> p) \<subseteq> q"
by (auto simp add: module_def)
{
fix xs
assume "xs \<in> pow_inv {Act (to_fun S) |S. S \<subseteq> r}"
hence "map \<langle>id,id\<rangle> ` (xs \<sha> [\<Gamma> a]) \<Colon> p \<subseteq> q"
proof (induct xs, simp add: atom')
fix x and xs
assume x_set: "x \<in> {Act (to_fun S) |S. S \<subseteq> r}"
and xs_set: "xs \<in> pow_inv {Act (to_fun S) |S. S \<subseteq> r}"
and ih: "map \<langle>id,id\<rangle> ` (xs \<sha> [\<Gamma> a]) \<Colon> p \<subseteq> q"
have "{[x]} \<Colon> p \<subseteq> p"
by (rule singleton_stable[OF p_stable x_set])
hence x_first: "op # x ` map \<langle>id,id\<rangle> ` (xs \<sha> [\<Gamma> a]) \<Colon> p \<subseteq> q"
by (simp add: mod_cons mod_mult) (metis (hide_lams, no_types) ih mod_isor subset_trans)
have "x # xs \<in> pow_inv {Act (to_fun S) |S. S \<subseteq> r}"
by (smt pow_inv.pinv_cons x_set xs_set)
hence "{x#xs} \<Colon> q \<subseteq> q"
by (metis \<rho>_def mod_forall q_stable stable_def)
from x_first and this show "map \<langle>id,id\<rangle> ` ((x # xs) \<sha> [\<Gamma> a]) \<Colon> p \<subseteq> q"
apply (simp only: tshuffle_ind image_Un mod_distl, simp, subst mod_cons_var, subst mod_mult)
by (metis atom' mod_isor subset_trans)
qed
}
thus "r, {(\<sigma>,\<sigma>'). \<sigma>' \<in> runAct (\<Gamma> a) \<sigma>} \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> Atom a \<lbrace>q\<rbrace>"
apply (simp add: quintuple_def)
apply (intro conjI)
apply (insert p_stable)
defer
apply (simp add: to_rel_def \<iota>_def symbols_def)
apply (simp add: stable_def)
apply (simp add: \<rho>_def shuffle_def)
apply (subst mod_continuous_var)
apply (subst Sup_image_le_iff)
by auto
qed
lemma WEAKEN: "r' \<subseteq> r \<Longrightarrow> g \<subseteq> g' \<Longrightarrow> p' \<subseteq> p \<Longrightarrow> q \<subseteq> q' \<Longrightarrow> r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> C \<lbrace>q\<rbrace> \<Longrightarrow> r', g' \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p'\<rbrace> C \<lbrace>q'\<rbrace>"
apply (simp add: quintuple_def)
by (metis \<rho>_iso mod_isol mod_isor order_trans shuffle_iso)
lemmas WEAKEN_RELY = WEAKEN[OF _ subset_refl subset_refl subset_refl]
and STRENGTHEN_GUAR = WEAKEN[OF subset_refl _ subset_refl subset_refl]
and WEAKEN_PRE = WEAKEN[OF subset_refl subset_refl _ subset_refl]
and STRENGTHEN_POST = WEAKEN[OF subset_refl subset_refl subset_refl _]
lemma ATOM_VAR:
assumes atom: "\<forall>\<sigma>\<in>p. runAct (\<Gamma> a) \<sigma> \<subseteq> q"
and p_stable: "stable r p"
and q_stable: "stable r q"
and guar: "{(\<sigma>,\<sigma>'). \<sigma>' \<in> runAct (\<Gamma> a) \<sigma>} \<subseteq> g"
shows "r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p\<rbrace> Atom a \<lbrace>q\<rbrace>"
apply (rule STRENGTHEN_GUAR[OF guar])
apply (rule ATOM)
apply (metis atom)
apply (metis p_stable)
by (metis q_stable)
abbreviation quintuple' :: "mem rel \<Rightarrow> mem rel \<Rightarrow> mem set \<Rightarrow> (atoms, mem) stmt \<Rightarrow> mem set \<Rightarrow> bool"
("_, _ \<turnstile>// \<lbrace>_\<rbrace>// _// \<lbrace>_\<rbrace>" [20,20,20,20,20] 100) where
"r, g \<turnstile> \<lbrace>p\<rbrace> c \<lbrace>q\<rbrace> \<equiv> r, g \<turnstile>\<^bsub>atoms_interp\<^esub> \<lbrace>p\<rbrace> c \<lbrace>q\<rbrace>"
definition maps_to :: "nat \<Rightarrow> nat \<Rightarrow> mem set" (infix "\<mapsto>" 95) where
"v \<mapsto> n \<equiv> {\<sigma>. \<sigma> v = Some n}"
definition maps_to_any :: "nat \<Rightarrow> mem set" ("_ \<mapsto> -" [96] 95) where
"v \<mapsto> - = {\<sigma>. \<exists>n. \<sigma> v = Some n}"
abbreviation assignment :: "nat \<Rightarrow> nat \<Rightarrow> (atoms, mem) stmt" (infix ":=" 95) where
"assignment v n \<equiv> Atom (Assign v n)"
abbreviation Test :: "mem set \<Rightarrow> (atoms, mem) stmt" where "Test t \<equiv> Atom (Pred t)"
lemma [simp]: "semantics atoms_interp (Test t) \<Colon> h = h \<inter> t"
by (auto simp add: module_def)
definition Await :: "mem set \<Rightarrow> (atoms, mem) stmt \<Rightarrow> (atoms, mem) stmt" where
"Await b C = Seq (Test b) C"
definition "unchanged V \<equiv> {(\<sigma>,\<sigma>'). \<forall>v\<in>V. \<sigma> v = \<sigma>' v}"
definition "preserves b \<equiv> {(\<sigma>,\<sigma>'). \<sigma> \<in> b \<longrightarrow> \<sigma>' \<in> b}"
lemma AWAIT:
assumes "\<exists>C11 C12 C13."
shows "r, g \<turnstile> \<lbrace>p\<rbrace> Par C1 (Await b C2) \<lbrace>q1 \<inter> q2\<rbrace>"
lemma ASSIGN:
shows "unchanged {v}, {(\<sigma>,\<sigma>'). \<sigma>' v = Some n \<and> (\<forall>v'. v' \<noteq> v \<longrightarrow> \<sigma> v' = \<sigma>' v')} \<turnstile> \<lbrace>v \<mapsto> -\<rbrace> v := n \<lbrace>v \<mapsto> n\<rbrace>"
sorry
abbreviation K :: "bool \<Rightarrow> 'a set" where "K t \<equiv> {s. t}"
lemma disj1: "(x \<mapsto> - ** y \<mapsto> -) = (K (x \<noteq> y) \<inter> x \<mapsto> - ** K (x \<noteq> y) \<inter> y \<mapsto> -)"
by (auto simp add: sep_conj_def maps_to_any_def disjoint_def domain_def)
lemma empty_mod: "x \<Colon> {} = {}"
by (simp add: module_def eval_word_def)
lemma CONST: "(p' \<Longrightarrow> r, g \<turnstile> \<lbrace>p\<rbrace> C1 \<lbrace>q\<rbrace>) \<Longrightarrow> r, g \<turnstile> \<lbrace>K p' \<inter> p\<rbrace> C1 \<lbrace>q\<rbrace>"
apply (simp add: quintuple_def empty_mod)
by (metis Un_empty_left empty_subsetI galois_connection inv_join shuffle_zerol subset_empty)
lemma "x \<mapsto> n \<subseteq> x \<mapsto> -"
by (auto simp add: maps_to_def maps_to_any_def)
lemma empty_rely1: "\<rho> {} \<Colon> p \<subseteq> p"
proof (auto simp add: \<rho>_def module_def eval_word_def)
fix w x \<sigma>
assume "w \<in> pow_inv {Act (\<lambda>x. {})}" and "x \<in> runAct (listsum w) \<sigma>"
and "\<sigma> \<in> p"
thus "x \<in> p"
by (induct w rule: pow_inv.induct) (simp_all add: zero_act_def plus_act_def)
qed
lemma empty_rely2: "p \<subseteq> \<rho> {} \<Colon> p"
apply (simp add: \<rho>_def module_def eval_word_def)
apply auto
apply (rule_tac x = p in exI)
apply (intro conjI)
apply auto
apply (rule_tac x = "[]" in exI)
by (auto simp add: zero_act_def)
lemma empty_rely [simp]: "\<rho> {} \<Colon> p = p"
by (metis empty_rely1 empty_rely2 subset_antisym)
lemma "{}, UNIV \<turnstile> \<lbrace>x \<mapsto> n\<rbrace> Skip \<lbrace>x \<mapsto> -\<rbrace>"
by (auto simp add: quintuple_def maps_to_any_def maps_to_def)
datatype ('a, 'b) rg_block =
RGPar "('a, 'b) stmt" "('a, 'b) rg_block"
| RGEnd "('a, 'b) stmt"
definition rg_block :: "'b rel \<Rightarrow> ('a, 'b) stmt \<Rightarrow> 'b rel \<Rightarrow> ('a, 'b) rg_block \<Rightarrow> ('a, 'b) rg_block" ("// RELY _// DO _// GUAR _; _" [31,31,31,30] 30) where
"RELY r DO C GUAR g; prog \<equiv> RGPar C prog"
definition rg_block_end :: "'b rel \<Rightarrow> ('a, 'b) stmt \<Rightarrow> 'b rel \<Rightarrow> ('a, 'b) rg_block" ("// RELY _// DO _// GUAR _//COEND" [31,31,31] 30) where
"RELY r DO C GUAR g COEND \<equiv> RGEnd C"
primrec cobegin :: "('a, 'b) rg_block \<Rightarrow> ('a, 'b) stmt" ("COBEGIN _" [30] 30) where
"cobegin (RGPar c rg) = Par c (cobegin rg)"
| "cobegin (RGEnd c) = c"
abbreviation triple' :: "mem set \<Rightarrow> (atoms, mem) stmt \<Rightarrow> mem set \<Rightarrow> bool"
("\<lbrace>_\<rbrace>// _// \<lbrace>_\<rbrace>" [20,20,20] 100) where
"\<lbrace>p\<rbrace> c \<lbrace>q\<rbrace> \<equiv> {}, UNIV \<turnstile>\<^bsub>atoms_interp\<^esub> \<lbrace>p\<rbrace> c \<lbrace>q\<rbrace>"
lemma COBEGIN:
assumes "r1, g1 \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p1\<rbrace> C1 \<lbrace>q1\<rbrace>"
and "r2, g2 \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p2\<rbrace> C2 \<lbrace>q2\<rbrace>"
and "g1 \<subseteq> r2" and "g2 \<subseteq> r1"
and "r \<subseteq> r1 \<inter> r2" and "g1 \<union> g2 \<subseteq> g"
shows "r, g \<turnstile>\<^bsub>\<Gamma>\<^esub> \<lbrace>p1 \<inter> p2\<rbrace> COBEGIN RELY r1 DO C1 GUAR g1; RELY r2 DO C2 GUAR g2 COEND \<lbrace>q1 \<inter> q2\<rbrace>"
apply (rule WEAKEN[OF assms(5) assms(6) subset_refl subset_refl])
using assms
by (auto simp add: rg_block_def rg_block_end_def intro: PAR)
definition PAR_ASSIGN :: "nat \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow> (atoms, mem) stmt" ("_, _ := _, _" [96,96,96,96] 95) where
"PAR_ASSIGN x y n m \<equiv>
COBEGIN
RELY unchanged {x}
DO x := n
GUAR unchanged (- {x});
RELY unchanged {y}
DO y := m
GUAR unchanged (- {y})
COEND"
lemma PAR_ASSIGN:
"x \<noteq> y \<Longrightarrow> unchanged {x, y}, unchanged (- {x, y}) \<turnstile> \<lbrace>x \<mapsto> - \<inter> y \<mapsto> -\<rbrace> x, y := n, m \<lbrace>x \<mapsto> n \<inter> y \<mapsto> m\<rbrace>"
apply (simp add: PAR_ASSIGN_def)
apply (rule COBEGIN)
apply (rule WEAKEN[OF _ _ subset_refl subset_refl])
prefer 3
apply (rule ASSIGN)
prefer 3
apply (rule WEAKEN[OF _ _ subset_refl subset_refl])
prefer 3
apply (rule ASSIGN)
by (auto simp add: unchanged_def)
lemma PAR_ASSIGN: "x \<noteq> y \<Longrightarrow> {}, UNIV \<turnstile> \<lbrace>x \<mapsto> - \<inter> y \<mapsto> -\<rbrace> Par (x := n) (y := m) \<lbrace>x \<mapsto> n \<inter> y \<mapsto> m\<rbrace>"
apply (rule STRENGTHEN_GUAR[of "unchanged (- {x}) \<union> unchanged (- {y})"])
apply simp
apply (rule WEAKEN_RELY[of _ "unchanged (- {y}) \<inter> unchanged (- {x})"])
apply simp
apply (rule PAR)
apply simp
apply (rule WEAKEN[OF _ _ subset_refl subset_refl])
prefer 3
apply (rule ASSIGN)
apply (force simp add: unchanged_def)+
apply (rule WEAKEN[OF _ _ subset_refl subset_refl])
prefer 3
apply (rule ASSIGN)
by (force simp add: unchanged_def)+
end
|
%!TEX root = ../main.tex
\chapter{Nocturnal Xylem}
\section{Linear Regression}
\lipsum[1-5]
\section{Accumulation of Bayesian Gravity}
\lipsum[1-4] |
example (p q r : Prop) : p β§ (q β¨ r) β (p β§ q) β¨ (p β§ r) :=
begin
apply iff.intro,
intro h,
cases h.right with hq hr,
show (p β§ q) β¨ (p β§ r),
{ left, split, exact h.left, assumption },
show (p β§ q) β¨ (p β§ r),
{ right, split, exact h.left, assumption },
intro h,
cases h with hpq hpr,
show p β§ (q β¨ r),
{ cases hpq, split, assumption, left, assumption },
show p β§ (q β¨ r),
{ cases hpr, split, assumption, right, assumption }
end
|
### A Pluto.jl notebook ###
# v0.14.4
using Markdown
using InteractiveUtils
# βββ‘ 12bae146-12e7-4a78-afac-f5c2d6b86b66
begin
using PlutoUI
PlutoUI.TableOfContents(aside=true)
end
# βββ‘ 7be5652e-3e5a-4199-a099-40f2da28053c
using LinearAlgebra, Arpack, LinearMaps, SparseArrays
# βββ‘ 4b63c1d9-f043-448f-9e05-911f52d4227d
begin
using Random
Random.seed!(421)
n=100
A=Matrix(Symmetric(rand(n,n)))
# Or: A = rand(5,5) |> t -> t + t'
x=rand(n)
k=10
end
# βββ‘ f647d0dd-1fe4-42cf-b55c-38baa12f2db8
md"""
# Symmetric Eigenvalue Decomposition - Lanczos Method
If the matrix $A$ is large and sparse and/or if only some eigenvalues and their eigenvectors are desired, iterative methods are the methods of choice. For example, the power method can be useful to compute the eigenvalue with the largest modulus. The basic operation in the power method is matrix-vector multiplication, and this can be performed very fast if $A$ is sparse. Moreover, $A$ need not be stored in the computer -- the input for the algorithm can be just a function which, given some vector $x$, returns the product $Ax$.
An _improved_ version of the power method, which efficiently computes some eigenvalues (either largest in modulus or near some target value $\mu$) and the corresponding eigenvectors, is the Lanczos method.
For more details, see [I. SlapniΔar, Symmetric Matrix Eigenvalue Techniques, pp. 55.1-55.25](https://www.routledge.com/Handbook-of-Linear-Algebra/Hogben/p/book/9781138199897) and the references therein.
__Prerequisites__
The reader should be familiar with concepts of eigenvalues and eigenvectors, related perturbation theory, and algorithms.
__Competences__
The reader should be able to recognise matrices which warrant use uf Lanczos method, to apply the method and to assess the accuracy of the solution.
"""
# βββ‘ d5f270bd-94c1-4da6-a8e6-a53337488020
md"""
# Lanczos method
$A$ is a real symmetric matrix of order $n$.
## Definitions
Given a nonzero vector $x$ and an index $k<n$, the __Krylov matrix__ is defined as
$$
K_k=\begin{bmatrix} x & Ax & A^2 x &\cdots & A^{k-1}x \end{bmatrix}.$$
__Krilov subspace__ is the subspace spanned by the columns of $K_k$.
## Facts
1. The Lanczos method is based on the following observation. If $K_k=XR$ is the $QR$ factorization of the matrix $K_k$, then the $k\times k$ matrix $T=X^T A X$ is tridiagonal. The matrices $X$ and $T$ can be computed by using only matrix-vector products in $O(kn)$ operations.
2. Let $T=Q\Lambda Q^T$ be the EVD of $T$. Then $\lambda_i$ approximate well some of the largest and smallest eigenvalues of $A$, and the columns of the matrix $U=XQ$ approximate the corresponding eigenvectors.
3. As $k$ increases, the largest (smallest) eigenvalues of the matrix $T_{1:k,1:k}$ converge towards some of the largest (smallest) eigenvalues of $A$ (due to the Cauchy interlace property). The algorithm can be redesigned to compute only largest or smallest eigenvalues. Also, by using shift and invert strategy, the method can be used to compute eigenvalues near some specified value. In order to obtain better approximations, $k$ should be greater than the number of required eigenvalues. On the other side, in order to obtain better accuracy and efficacy, $k$ should be as small as possible.
4. The last computed element, $\mu=T_{k+1,k}$, provides information about accuracy:
$$
\begin{aligned}
\|AU-U\Lambda\|_2&=\mu, \\
\|AU_{:,i}-\lambda_i U_{:,i}\|_2&=\mu |Q_{ki}|, \quad i=1,\ldots,k.
\end{aligned}$$
Further, there are $k$ eigenvalues $\tilde\lambda_1,\ldots,\tilde\lambda_k$ of $A$ such that $|\lambda_i-\tilde\lambda_i|\leq \mu$, and for the corresponding eigenvectors, we have
$$\sin2\Theta(U_{:,i},\tilde U_{:,i}) \leq \frac{2\mu}{\min_{j\neq i} |\lambda_i-\tilde \lambda_j|}.$$
5. In practical implementations, $\mu$ is usually used to determine the index $k$.
6. The Lanczos method has inherent numerical instability in the floating-point arithmetic: since the Krylov vectors are, in fact, generated by the power method, they converge towards an eigenvector of $A$. Thus, as $k$ increases, the Krylov vectors become more and more parallel, and the recursion in the function `Lanczos()` becomes numerically unstable and the computed columns of $X$ cease to be sufficiently orthogonal. This affects both the convergence and the accuracy of the algorithm. For example, several eigenvalues of $T$ may converge towards a simple eigenvalue of $A$ (the, so called, __ghost eigenvalues__).
7. The loss of orthogonality is dealt with by using the __full reorthogonalization__ procedure: in each step, the new ${\bf z}$ is orthogonalized against all previous columns of $X$, that is, in function `Lanczos()`, the formula
```
z=z-Tr.dv[i]*X[:,i]-Tr.ev[i-1]*X[:,i-1]
```
is replaced by
```
z=z-sum(dot(z,Tr.dv[i])*X[:,i]-Tr.ev[i-1]*X[:,i-1]
```
To obtain better orthogonality, the latter formula is usually executed twice. The full reorthogonalization raises the operation count to $O(k^2n)$.
8. The __selective reorthogonalization__ is the procedure in which the current $z$ is orthogonalized against some selected columns of $X$, in order to attain sufficient numerical stability and not increase the operation count too much. The details are very subtle and can be found in the references.
9. The Lanczos method is usually used for sparse matrices. Sparse matrix $A$ is stored in the sparse format in which only values and indices of nonzero elements are stored. The number of operations required to multiply some vector by $A$ is also proportional to the number of nonzero elements.
10. The function `eigs()` implements Lanczos method real for symmetric matrices and more general Arnoldi method for general matrices.
"""
# βββ‘ 97e0dbf8-b9be-4503-af5d-4cf6e86311eb
function Lanczos(A::Array{T}, x::Vector{T}, k::Int) where T
n=size(A,1)
X=Array{T}(undef,n,k)
dv=Array{T}(undef,k)
ev=Array{T}(undef,k-1)
X[:,1]=x/norm(x)
for i=1:k-1
z=A*X[:,i]
dv[i]=X[:,i]β
z
# Three-term recursion
if i==1
z=z-dv[i]*X[:,i]
else
# z=z-dv[i]*X[:,i]-ev[i-1]*X[:,i-1]
# Full reorthogonalization - once or even twice
z=z-sum([(zβ
X[:,j])*X[:,j] for j=1:i])
z=z-sum([(zβ
X[:,j])*X[:,j] for j=1:i])
end
ΞΌ=norm(z)
if ΞΌ==0
Tr=SymTridiagonal(dv[1:i-1],ev[1:i-2])
return eigvals(Tr), X[:,1:i-1]*eigvecs(Tr), X[:,1:i-1], ΞΌ
else
ev[i]=ΞΌ
X[:,i+1]=z/ΞΌ
end
end
# Last step
z=A*X[:,end]
dv[end]=X[:,end]β
z
z=z-dv[end]*X[:,end]-ev[end]*X[:,end-1]
ΞΌ=norm(z)
Tr=SymTridiagonal(dv,ev)
eigvals(Tr), X*eigvecs(Tr), X, ΞΌ
end
# βββ‘ 219ce78b-8bd3-4df3-93df-c08fad30e33f
Ξ»,U,X,ΞΌ=Lanczos(A,x,10)
# βββ‘ 1ef82905-e422-4644-ad00-26c448cb0e3a
# Orthogonality of X
norm(X'*X-I)
# βββ‘ 595b22a5-4456-41fb-b4d6-861833bc6d47
# Tridiagonalization
X'*A*X
# βββ‘ b2e762d4-650c-4846-ae30-32614b516fe3
# Residual
norm(A*U-U*Diagonal(Ξ»)), ΞΌ
# βββ‘ bd2b8d59-0525-4db5-99cd-e2f98f735eda
U'*A*U
# βββ‘ 6791903f-0cf7-4bbc-adfb-ff9e80b373dc
# Orthogonality of U
norm(U'*U-I)
# βββ‘ 218a2a21-e391-4a90-a96a-71bbb0d2f895
# Full eigenvalue decomposition
Ξ»eigen,Ueigen=eigen(A);
# βββ‘ e23c1bc6-c4d8-4c5d-9a83-2b00c5d93b25
# ?eigs
# βββ‘ fc00c272-d66f-42be-9964-7a934b32015c
# Lanczos method from Arpack.jl
Ξ»eigs,Ueigs=eigs(A; nev=k, which=:LM, ritzvec=true, v0=x)
# βββ‘ 91eec1a8-413c-4960-bb52-8da2435e9e4a
[Ξ» Ξ»eigs Ξ»eigen[sortperm(abs.(Ξ»eigen),rev=true)[1:k]] ]
# βββ‘ aa20cf19-2bc8-4831-ae26-fb883614c63f
md"""
We see that `eigs()` computes `k` eigenvalues with largest modulus. What eigenvalues did `Lanczos()` compute?
"""
# βββ‘ 9ce7a012-723d-4184-8ef3-00f468e61281
for i=1:k
println(minimum(abs,Ξ»eigen.-Ξ»[i]))
end
# βββ‘ ed7d1400-e6d9-44e2-a633-7f6b3df74272
md"""
Conslusion is that the naive implementation of Lanczos is not enough. However, it is fine, when all eigenvalues are computed. Why?
"""
# βββ‘ d2f31110-5587-4dd3-a5cf-cc3e046e1ee0
Ξ»all,Uall,Xall,ΞΌall=Lanczos(A,x,100)
# βββ‘ 04763c96-3a2b-4092-8969-99c18cc8fd54
# Residual and relative errors
norm(A*Uall-Uall*Diagonal(Ξ»all)), norm((Ξ»eigen-Ξ»all)./Ξ»eigen)
# βββ‘ 95ef94d2-129f-4dbb-b705-9a2c8660e22e
md"""
# Operator version
We can use Lanczos method with operator which, given vector `x`, returns the product `A*x`. We use the function `LinearMap()` from the package [LinearMaps.jl](https://github.com/Jutho/LinearMaps.jl)
"""
# βββ‘ b8716ffe-8405-4018-bdb9-29c8cd2243dc
# ?LinearMap
# βββ‘ 3bd1283d-91fa-4fdd-bcf8-946ac83b848c
# Operator from the matrix
C=LinearMap(A)
# βββ‘ 0f8596c1-ee32-4b0d-b13b-d36fb611c99e
begin
Ξ»C,UC=eigs(C; nev=k, which=:LM, ritzvec=true, v0=x)
Ξ»eigs-Ξ»C
end
# βββ‘ 05cd7b4e-18cf-485c-8113-4855f22ac8a0
md"""
Here is an example of `LinearMap()` with the function.
"""
# βββ‘ a8aeb3ce-5a67-48c7-9c15-8cc11e7ec39b
f(x)=A*x
# βββ‘ 86bcfb51-6508-4644-ab3d-ee5d9675e1d6
D=LinearMap(f,n,issymmetric=true)
# βββ‘ 5c08501f-010a-4d17-96b7-e339b0299262
begin
Ξ»D,UD=eigs(D, nev=k, which=:LM, ritzvec=true, v0=x)
Ξ»eigs-Ξ»D
end
# βββ‘ 8a8d59cb-0a69-412e-948e-8110f04419fe
md"""
# Sparse matrices
"""
# βββ‘ f63b3be6-f5d4-49c7-b8c7-a03826f21ad4
# ?sprand
# βββ‘ 7beaf848-ad66-47ff-9411-b4ea94476f38
# Generate a sparse symmetric matrix
Cβ=sprand(n,n,0.05) |> t -> t+t'
# βββ‘ d468bf54-54ad-4f07-87d7-ce3d666471aa
issymmetric(Cβ)
# βββ‘ 0f9a4d39-c00c-44b2-8831-eeca1b34e79c
eigs(Cβ; nev=k, which=:LM, ritzvec=true, v0=x)
# βββ‘ a2384a29-511e-43b5-831d-b5b9c2e85ef0
# βββ‘ Cell order:
# ββ12bae146-12e7-4a78-afac-f5c2d6b86b66
# ββf647d0dd-1fe4-42cf-b55c-38baa12f2db8
# ββd5f270bd-94c1-4da6-a8e6-a53337488020
# β β7be5652e-3e5a-4199-a099-40f2da28053c
# β β97e0dbf8-b9be-4503-af5d-4cf6e86311eb
# β β4b63c1d9-f043-448f-9e05-911f52d4227d
# β β219ce78b-8bd3-4df3-93df-c08fad30e33f
# β β1ef82905-e422-4644-ad00-26c448cb0e3a
# β β595b22a5-4456-41fb-b4d6-861833bc6d47
# β βb2e762d4-650c-4846-ae30-32614b516fe3
# β βbd2b8d59-0525-4db5-99cd-e2f98f735eda
# β β6791903f-0cf7-4bbc-adfb-ff9e80b373dc
# β β218a2a21-e391-4a90-a96a-71bbb0d2f895
# β βe23c1bc6-c4d8-4c5d-9a83-2b00c5d93b25
# β βfc00c272-d66f-42be-9964-7a934b32015c
# β β91eec1a8-413c-4960-bb52-8da2435e9e4a
# ββaa20cf19-2bc8-4831-ae26-fb883614c63f
# β β9ce7a012-723d-4184-8ef3-00f468e61281
# ββed7d1400-e6d9-44e2-a633-7f6b3df74272
# β βd2f31110-5587-4dd3-a5cf-cc3e046e1ee0
# β β04763c96-3a2b-4092-8969-99c18cc8fd54
# ββ95ef94d2-129f-4dbb-b705-9a2c8660e22e
# β βb8716ffe-8405-4018-bdb9-29c8cd2243dc
# β β3bd1283d-91fa-4fdd-bcf8-946ac83b848c
# β β0f8596c1-ee32-4b0d-b13b-d36fb611c99e
# ββ05cd7b4e-18cf-485c-8113-4855f22ac8a0
# β βa8aeb3ce-5a67-48c7-9c15-8cc11e7ec39b
# β β86bcfb51-6508-4644-ab3d-ee5d9675e1d6
# β β5c08501f-010a-4d17-96b7-e339b0299262
# ββ8a8d59cb-0a69-412e-948e-8110f04419fe
# β βf63b3be6-f5d4-49c7-b8c7-a03826f21ad4
# β β7beaf848-ad66-47ff-9411-b4ea94476f38
# β βd468bf54-54ad-4f07-87d7-ce3d666471aa
# β β0f9a4d39-c00c-44b2-8831-eeca1b34e79c
# β βa2384a29-511e-43b5-831d-b5b9c2e85ef0
|
If two maps $f$ and $g$ are homotopic, then the image of $f$ is a subset of the codomain of $g$. |
lemma eventually_at_le: "eventually P (at a within S) \<longleftrightarrow> (\<exists>d>0. \<forall>x\<in>S. x \<noteq> a \<and> dist x a \<le> d \<longrightarrow> P x)" for a :: "'a::metric_space" |
/-
Copyright (c) 2018 Scott Morrison. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Scott Morrison, Johan Commelin, Bhavik Mehta
! This file was ported from Lean 3 source module category_theory.comma
! leanprover-community/mathlib commit 8a318021995877a44630c898d0b2bc376fceef3b
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.CategoryTheory.Isomorphism
import Mathbin.CategoryTheory.Functor.Category
import Mathbin.CategoryTheory.EqToHom
/-!
# Comma categories
> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.
A comma category is a construction in category theory, which builds a category out of two functors
with a common codomain. Specifically, for functors `L : A β₯€ T` and `R : B β₯€ T`, an object in
`comma L R` is a morphism `hom : L.obj left βΆ R.obj right` for some objects `left : A` and
`right : B`, and a morphism in `comma L R` between `hom : L.obj left βΆ R.obj right` and
`hom' : L.obj left' βΆ R.obj right'` is a commutative square
```
L.obj left βΆ L.obj left'
| |
hom | | hom'
β β
R.obj right βΆ R.obj right',
```
where the top and bottom morphism come from morphisms `left βΆ left'` and `right βΆ right'`,
respectively.
## Main definitions
* `comma L R`: the comma category of the functors `L` and `R`.
* `over X`: the over category of the object `X` (developed in `over.lean`).
* `under X`: the under category of the object `X` (also developed in `over.lean`).
* `arrow T`: the arrow category of the category `T` (developed in `arrow.lean`).
## References
* <https://ncatlab.org/nlab/show/comma+category>
## Tags
comma, slice, coslice, over, under, arrow
-/
namespace CategoryTheory
-- declare the `v`'s first; see `category_theory.category` for an explanation
universe vβ vβ vβ vβ vβ
uβ uβ uβ uβ uβ
variable {A : Type uβ} [Category.{vβ} A]
variable {B : Type uβ} [Category.{vβ} B]
variable {T : Type uβ} [Category.{vβ} T]
#print CategoryTheory.Comma /-
/-- The objects of the comma category are triples of an object `left : A`, an object
`right : B` and a morphism `hom : L.obj left βΆ R.obj right`. -/
structure Comma (L : A β₯€ T) (R : B β₯€ T) : Type max uβ uβ vβ where
left : A
right : B
Hom : L.obj left βΆ R.obj right
#align category_theory.comma CategoryTheory.Comma
-/
#print CategoryTheory.Comma.inhabited /-
-- Satisfying the inhabited linter
instance Comma.inhabited [Inhabited T] : Inhabited (Comma (π T) (π T))
where default :=
{ left := default
right := default
Hom := π default }
#align category_theory.comma.inhabited CategoryTheory.Comma.inhabited
-/
variable {L : A β₯€ T} {R : B β₯€ T}
#print CategoryTheory.CommaMorphism /-
/-- A morphism between two objects in the comma category is a commutative square connecting the
morphisms coming from the two objects using morphisms in the image of the functors `L` and `R`.
-/
@[ext]
structure CommaMorphism (X Y : Comma L R) where
left : X.left βΆ Y.left
right : X.right βΆ Y.right
w' : L.map left β« Y.Hom = X.Hom β« R.map right := by obviously
#align category_theory.comma_morphism CategoryTheory.CommaMorphism
-/
#print CategoryTheory.CommaMorphism.inhabited /-
-- Satisfying the inhabited linter
instance CommaMorphism.inhabited [Inhabited (Comma L R)] :
Inhabited (CommaMorphism (default : Comma L R) default) :=
β¨β¨π _, π _β©β©
#align category_theory.comma_morphism.inhabited CategoryTheory.CommaMorphism.inhabited
-/
restate_axiom comma_morphism.w'
attribute [simp, reassoc.1] comma_morphism.w
#print CategoryTheory.commaCategory /-
instance commaCategory : Category (Comma L R)
where
Hom := CommaMorphism
id X :=
{ left := π X.left
right := π X.right }
comp X Y Z f g :=
{ left := f.left β« g.left
right := f.right β« g.right }
#align category_theory.comma_category CategoryTheory.commaCategory
-/
namespace Comma
section
variable {X Y Z : Comma L R} {f : X βΆ Y} {g : Y βΆ Z}
#print CategoryTheory.Comma.id_left /-
@[simp]
theorem id_left : (π X : CommaMorphism X X).left = π X.left :=
rfl
#align category_theory.comma.id_left CategoryTheory.Comma.id_left
-/
#print CategoryTheory.Comma.id_right /-
@[simp]
theorem id_right : (π X : CommaMorphism X X).right = π X.right :=
rfl
#align category_theory.comma.id_right CategoryTheory.Comma.id_right
-/
#print CategoryTheory.Comma.comp_left /-
@[simp]
theorem comp_left : (f β« g).left = f.left β« g.left :=
rfl
#align category_theory.comma.comp_left CategoryTheory.Comma.comp_left
-/
#print CategoryTheory.Comma.comp_right /-
@[simp]
theorem comp_right : (f β« g).right = f.right β« g.right :=
rfl
#align category_theory.comma.comp_right CategoryTheory.Comma.comp_right
-/
end
variable (L) (R)
#print CategoryTheory.Comma.fst /-
/-- The functor sending an object `X` in the comma category to `X.left`. -/
@[simps]
def fst : Comma L R β₯€ A where
obj X := X.left
map _ _ f := f.left
#align category_theory.comma.fst CategoryTheory.Comma.fst
-/
#print CategoryTheory.Comma.snd /-
/-- The functor sending an object `X` in the comma category to `X.right`. -/
@[simps]
def snd : Comma L R β₯€ B where
obj X := X.right
map _ _ f := f.right
#align category_theory.comma.snd CategoryTheory.Comma.snd
-/
#print CategoryTheory.Comma.natTrans /-
/-- We can interpret the commutative square constituting a morphism in the comma category as a
natural transformation between the functors `fst β L` and `snd β R` from the comma category
to `T`, where the components are given by the morphism that constitutes an object of the comma
category. -/
@[simps]
def natTrans : fst L R β L βΆ snd L R β R where app X := X.Hom
#align category_theory.comma.nat_trans CategoryTheory.Comma.natTrans
-/
#print CategoryTheory.Comma.eqToHom_left /-
@[simp]
theorem eqToHom_left (X Y : Comma L R) (H : X = Y) :
CommaMorphism.left (eqToHom H) =
eqToHom
(by
cases H
rfl) :=
by
cases H
rfl
#align category_theory.comma.eq_to_hom_left CategoryTheory.Comma.eqToHom_left
-/
#print CategoryTheory.Comma.eqToHom_right /-
@[simp]
theorem eqToHom_right (X Y : Comma L R) (H : X = Y) :
CommaMorphism.right (eqToHom H) =
eqToHom
(by
cases H
rfl) :=
by
cases H
rfl
#align category_theory.comma.eq_to_hom_right CategoryTheory.Comma.eqToHom_right
-/
section
variable {Lβ Lβ Lβ : A β₯€ T} {Rβ Rβ Rβ : B β₯€ T}
/- warning: category_theory.comma.iso_mk -> CategoryTheory.Comma.isoMk is a dubious translation:
lean 3 declaration is
forall {A : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} A] {B : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} B] {T : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} T] {Lβ : CategoryTheory.Functor.{u1, u3, u4, u6} A _inst_1 T _inst_3} {Rβ : CategoryTheory.Functor.{u2, u3, u5, u6} B _inst_2 T _inst_3} {X : CategoryTheory.Comma.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ} {Y : CategoryTheory.Comma.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ} (l : CategoryTheory.Iso.{u1, u4} A _inst_1 (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (r : CategoryTheory.Iso.{u2, u5} B _inst_2 (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)), (Eq.{succ u3} (Quiver.Hom.{succ u3, u6} T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y))) (CategoryTheory.CategoryStruct.comp.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X)) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (CategoryTheory.Functor.map.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y) (CategoryTheory.Iso.hom.{u1, u4} A _inst_1 (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y) l)) (CategoryTheory.Comma.hom.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (CategoryTheory.CategoryStruct.comp.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (CategoryTheory.Comma.hom.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Functor.map.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y) (CategoryTheory.Iso.hom.{u2, u5} B _inst_2 (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y) r)))) -> (CategoryTheory.Iso.{max u1 u2, max u4 u5 u3} (CategoryTheory.Comma.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ) (CategoryTheory.commaCategory.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ) X Y)
but is expected to have type
forall {A : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} A] {B : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} B] {T : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} T] {Lβ : CategoryTheory.Functor.{u1, u3, u4, u6} A _inst_1 T _inst_3} {Rβ : CategoryTheory.Functor.{u2, u3, u5, u6} B _inst_2 T _inst_3} {X : CategoryTheory.Comma.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ} {Y : CategoryTheory.Comma.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ} (l : CategoryTheory.Iso.{u1, u4} A _inst_1 (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (r : CategoryTheory.Iso.{u2, u5} B _inst_2 (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)), (Eq.{succ u3} (Quiver.Hom.{succ u3, u6} T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (Prefunctor.obj.{succ u1, succ u3, u4, u6} A (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} A (CategoryTheory.Category.toCategoryStruct.{u1, u4} A _inst_1)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X)) (Prefunctor.obj.{succ u2, succ u3, u5, u6} B (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} B (CategoryTheory.Category.toCategoryStruct.{u2, u5} B _inst_2)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y))) (CategoryTheory.CategoryStruct.comp.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3) (Prefunctor.obj.{succ u1, succ u3, u4, u6} A (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} A (CategoryTheory.Category.toCategoryStruct.{u1, u4} A _inst_1)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X)) (Prefunctor.obj.{succ u1, succ u3, u4, u6} A (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} A (CategoryTheory.Category.toCategoryStruct.{u1, u4} A _inst_1)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (Prefunctor.obj.{succ u2, succ u3, u5, u6} B (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} B (CategoryTheory.Category.toCategoryStruct.{u2, u5} B _inst_2)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (Prefunctor.map.{succ u1, succ u3, u4, u6} A (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} A (CategoryTheory.Category.toCategoryStruct.{u1, u4} A _inst_1)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y) (CategoryTheory.Iso.hom.{u1, u4} A _inst_1 (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y) l)) (CategoryTheory.Comma.hom.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (CategoryTheory.CategoryStruct.comp.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3) (Prefunctor.obj.{succ u1, succ u3, u4, u6} A (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} A (CategoryTheory.Category.toCategoryStruct.{u1, u4} A _inst_1)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} A _inst_1 T _inst_3 Lβ) (CategoryTheory.Comma.left.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X)) (Prefunctor.obj.{succ u2, succ u3, u5, u6} B (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} B (CategoryTheory.Category.toCategoryStruct.{u2, u5} B _inst_2)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X)) (Prefunctor.obj.{succ u2, succ u3, u5, u6} B (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} B (CategoryTheory.Category.toCategoryStruct.{u2, u5} B _inst_2)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y)) (CategoryTheory.Comma.hom.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (Prefunctor.map.{succ u2, succ u3, u5, u6} B (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} B (CategoryTheory.Category.toCategoryStruct.{u2, u5} B _inst_2)) T (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} T (CategoryTheory.Category.toCategoryStruct.{u3, u6} T _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} B _inst_2 T _inst_3 Rβ) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y) (CategoryTheory.Iso.hom.{u2, u5} B _inst_2 (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ X) (CategoryTheory.Comma.right.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ Y) r)))) -> (CategoryTheory.Iso.{max u1 u2, max (max u4 u5) u3} (CategoryTheory.Comma.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ) (CategoryTheory.commaCategory.{u1, u2, u3, u4, u5, u6} A _inst_1 B _inst_2 T _inst_3 Lβ Rβ) X Y)
Case conversion may be inaccurate. Consider using '#align category_theory.comma.iso_mk CategoryTheory.Comma.isoMkβ'. -/
/-- Construct an isomorphism in the comma category given isomorphisms of the objects whose forward
directions give a commutative square.
-/
@[simps]
def isoMk {X Y : Comma Lβ Rβ} (l : X.left β
Y.left) (r : X.right β
Y.right)
(h : Lβ.map l.Hom β« Y.Hom = X.Hom β« Rβ.map r.Hom) : X β
Y
where
Hom :=
{ left := l.Hom
right := r.Hom }
inv :=
{ left := l.inv
right := r.inv
w' :=
by
rw [β Lβ.map_iso_inv l, iso.inv_comp_eq, Lβ.map_iso_hom, reassoc_of h, β Rβ.map_comp]
simp }
#align category_theory.comma.iso_mk CategoryTheory.Comma.isoMk
#print CategoryTheory.Comma.mapLeft /-
/-- A natural transformation `Lβ βΆ Lβ` induces a functor `comma Lβ R β₯€ comma Lβ R`. -/
@[simps]
def mapLeft (l : Lβ βΆ Lβ) : Comma Lβ R β₯€ Comma Lβ R
where
obj X :=
{ left := X.left
right := X.right
Hom := l.app X.left β« X.Hom }
map X Y f :=
{ left := f.left
right := f.right }
#align category_theory.comma.map_left CategoryTheory.Comma.mapLeft
-/
#print CategoryTheory.Comma.mapLeftId /-
/-- The functor `comma L R β₯€ comma L R` induced by the identity natural transformation on `L` is
naturally isomorphic to the identity functor. -/
@[simps]
def mapLeftId : mapLeft R (π L) β
π _
where
Hom :=
{
app := fun X =>
{ left := π _
right := π _ } }
inv :=
{
app := fun X =>
{ left := π _
right := π _ } }
#align category_theory.comma.map_left_id CategoryTheory.Comma.mapLeftId
-/
#print CategoryTheory.Comma.mapLeftComp /-
/-- The functor `comma Lβ R β₯€ comma Lβ R` induced by the composition of two natural transformations
`l : Lβ βΆ Lβ` and `l' : Lβ βΆ Lβ` is naturally isomorphic to the composition of the two functors
induced by these natural transformations. -/
@[simps]
def mapLeftComp (l : Lβ βΆ Lβ) (l' : Lβ βΆ Lβ) : mapLeft R (l β« l') β
mapLeft R l' β mapLeft R l
where
Hom :=
{
app := fun X =>
{ left := π _
right := π _ } }
inv :=
{
app := fun X =>
{ left := π _
right := π _ } }
#align category_theory.comma.map_left_comp CategoryTheory.Comma.mapLeftComp
-/
#print CategoryTheory.Comma.mapRight /-
/-- A natural transformation `Rβ βΆ Rβ` induces a functor `comma L Rβ β₯€ comma L Rβ`. -/
@[simps]
def mapRight (r : Rβ βΆ Rβ) : Comma L Rβ β₯€ Comma L Rβ
where
obj X :=
{ left := X.left
right := X.right
Hom := X.Hom β« r.app X.right }
map X Y f :=
{ left := f.left
right := f.right }
#align category_theory.comma.map_right CategoryTheory.Comma.mapRight
-/
#print CategoryTheory.Comma.mapRightId /-
/-- The functor `comma L R β₯€ comma L R` induced by the identity natural transformation on `R` is
naturally isomorphic to the identity functor. -/
@[simps]
def mapRightId : mapRight L (π R) β
π _
where
Hom :=
{
app := fun X =>
{ left := π _
right := π _ } }
inv :=
{
app := fun X =>
{ left := π _
right := π _ } }
#align category_theory.comma.map_right_id CategoryTheory.Comma.mapRightId
-/
#print CategoryTheory.Comma.mapRightComp /-
/-- The functor `comma L Rβ β₯€ comma L Rβ` induced by the composition of the natural transformations
`r : Rβ βΆ Rβ` and `r' : Rβ βΆ Rβ` is naturally isomorphic to the composition of the functors
induced by these natural transformations. -/
@[simps]
def mapRightComp (r : Rβ βΆ Rβ) (r' : Rβ βΆ Rβ) : mapRight L (r β« r') β
mapRight L r β mapRight L r'
where
Hom :=
{
app := fun X =>
{ left := π _
right := π _ } }
inv :=
{
app := fun X =>
{ left := π _
right := π _ } }
#align category_theory.comma.map_right_comp CategoryTheory.Comma.mapRightComp
-/
end
section
variable {C : Type uβ} [Category.{vβ} C] {D : Type uβ
} [Category.{vβ
} D]
#print CategoryTheory.Comma.preLeft /-
/-- The functor `(F β L, R) β₯€ (L, R)` -/
@[simps]
def preLeft (F : C β₯€ A) (L : A β₯€ T) (R : B β₯€ T) : Comma (F β L) R β₯€ Comma L R
where
obj X :=
{ left := F.obj X.left
right := X.right
Hom := X.Hom }
map X Y f :=
{ left := F.map f.left
right := f.right
w' := by simpa using f.w }
#align category_theory.comma.pre_left CategoryTheory.Comma.preLeft
-/
#print CategoryTheory.Comma.preRight /-
/-- The functor `(F β L, R) β₯€ (L, R)` -/
@[simps]
def preRight (L : A β₯€ T) (F : C β₯€ B) (R : B β₯€ T) : Comma L (F β R) β₯€ Comma L R
where
obj X :=
{ left := X.left
right := F.obj X.right
Hom := X.Hom }
map X Y f :=
{ left := f.left
right := F.map f.right
w' := by simp }
#align category_theory.comma.pre_right CategoryTheory.Comma.preRight
-/
#print CategoryTheory.Comma.post /-
/-- The functor `(L, R) β₯€ (L β F, R β F)` -/
@[simps]
def post (L : A β₯€ T) (R : B β₯€ T) (F : T β₯€ C) : Comma L R β₯€ Comma (L β F) (R β F)
where
obj X :=
{ left := X.left
right := X.right
Hom := F.map X.Hom }
map X Y f :=
{ left := f.left
right := f.right
w' := by simp only [functor.comp_map, β F.map_comp, f.w] }
#align category_theory.comma.post CategoryTheory.Comma.post
-/
end
end Comma
end CategoryTheory
|
import numpy as np
from astropy.time import Time
DAY_MICRO_SEC = 86400000000.
def uniq2orderipix(uniq):
"""
convert a HEALPix pixel coded as a NUNIQ number
to a (norder, ipix) tuple
"""
order = (np.log2(uniq // np.uint8(4))) // np.uint8(2)
order = order.astype(np.uint8)
ipix = uniq - np.uint64(4) * (np.uint64(4) ** np.uint64(order))
return order, ipix.astype(np.uint64)
def times_to_microseconds(times):
"""
Convert a `astropy.time.Time` into an array of integer microseconds since JD=0, keeping
the microsecond resolution required for `~mocpy.tmoc.TimeMOC`.
Parameters
----------
times : `astropy.time.Time`
Astropy observation times
Returns
-------
times_microseconds : `np.array`
"""
times_jd = np.asarray(times.jd, dtype=np.uint64)
times_us = np.asarray((times - Time(times_jd, format='jd', scale='tdb')).jd * DAY_MICRO_SEC, dtype=np.uint64)
return times_jd * np.uint64(DAY_MICRO_SEC) + times_us
def microseconds_to_times(times_microseconds):
"""
Convert an array of integer microseconds since JD=0, to an array of `astropy.time.Time`.
Parameters
----------
times_microseconds : `np.array`
Returns
-------
times : `astropy.time.Time`
"""
jd1 = np.asarray(times_microseconds // DAY_MICRO_SEC, dtype=np.float64)
jd2 = np.asarray((times_microseconds - jd1 * DAY_MICRO_SEC) / DAY_MICRO_SEC, dtype=np.float64)
return Time(val=jd1, val2=jd2, format='jd', scale='tdb')
|
#pragma once
#include <xul/std/istring_less.hpp>
#include <boost/intrusive_ptr.hpp>
#include <string>
namespace xul {
template <typename T>
class element_storage_traits : public element_traits<T>
{
public:
typedef T storage_type;
typedef typename element_traits<T>::accessor_type accessor_type;
typedef typename element_traits<T>::const_accessor_type const_accessor_type;
static accessor_type get_accessor(T val)
{
return val;
}
static const_accessor_type get_const_accessor(T val)
{
return val;
}
static T store(T v)
{
return v;
}
};
template <typename ObjectT>
class element_storage_traits<ObjectT *> : public element_traits<ObjectT*>
{
public:
typedef boost::intrusive_ptr<ObjectT> storage_type;
typedef typename element_traits<ObjectT*>::accessor_type accessor_type;
typedef typename element_traits<ObjectT*>::const_accessor_type const_accessor_type;
static accessor_type get_accessor(const boost::intrusive_ptr<ObjectT>& val)
{
return val.get();
}
static const_accessor_type get_const_accessor(const boost::intrusive_ptr<const ObjectT>& val)
{
return val.get();
}
static storage_type store(ObjectT* s)
{
return storage_type(s);
}
};
template <>
class element_storage_traits<const char*> : public element_traits<const char*>
{
public:
typedef std::string storage_type;
typedef element_traits<const char*>::accessor_type accessor_type;
typedef element_traits<const char*>::const_accessor_type const_accessor_type;
static accessor_type get_accessor(const std::string& val)
{
return val.c_str();
}
static const_accessor_type get_const_accessor(const std::string& val)
{
return val.c_str();
}
static std::string store(const char* s)
{
return std::string(s);
}
};
template <typename T>
class key_element_storage_traits
{
public:
typedef T accessor_type;
typedef T const_accessor_type;
typedef T input_type;
typedef T storage_type;
typedef std::less<T> comparer_type;
static accessor_type get_accessor(T val)
{
return val;
}
static const_accessor_type get_const_accessor(T val)
{
return val;
}
static T store(T v)
{
return v;
}
};
template <>
class key_element_storage_traits<const char*> : public element_storage_traits<const char*>
{
public:
typedef std::less<std::string> comparer_type;
};
class istring_key_element_storage_traits : public element_storage_traits<const char*>
{
public:
typedef istring_less<std::string> comparer_type;
};
}
|
[STATEMENT]
lemma rtrancl_O_push: "S\<^sup>* O R \<subseteq> R O S\<^sup>*"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. S\<^sup>* O R \<subseteq> R O S\<^sup>*
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. S\<^sup>* O R \<subseteq> R O S\<^sup>*
[PROOF STEP]
{
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. S\<^sup>* O R \<subseteq> R O S\<^sup>*
[PROOF STEP]
fix n
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. S\<^sup>* O R \<subseteq> R O S\<^sup>*
[PROOF STEP]
have "\<And>s t. (s,t) \<in> S ^^ n O R \<Longrightarrow> (s,t) \<in> R O S\<^sup>*"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
proof(induct n)
[PROOF STATE]
proof (state)
goal (2 subgoals):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
2. \<And>n s t. \<lbrakk>\<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*; (s, t) \<in> S ^^ Suc n O R\<rbrakk> \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
case (Suc n)
[PROOF STATE]
proof (state)
this:
(?s, ?t) \<in> S ^^ n O R \<Longrightarrow> (?s, ?t) \<in> R O S\<^sup>*
(s, t) \<in> S ^^ Suc n O R
goal (2 subgoals):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
2. \<And>n s t. \<lbrakk>\<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*; (s, t) \<in> S ^^ Suc n O R\<rbrakk> \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
(?s, ?t) \<in> S ^^ n O R \<Longrightarrow> (?s, ?t) \<in> R O S\<^sup>*
(s, t) \<in> S ^^ Suc n O R
[PROOF STEP]
obtain u where "(s,u) \<in> S" "(u,t) \<in> R O S\<^sup>*"
[PROOF STATE]
proof (prove)
using this:
(?s, ?t) \<in> S ^^ n O R \<Longrightarrow> (?s, ?t) \<in> R O S\<^sup>*
(s, t) \<in> S ^^ Suc n O R
goal (1 subgoal):
1. (\<And>u. \<lbrakk>(s, u) \<in> S; (u, t) \<in> R O S\<^sup>*\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
unfolding relpow_Suc
[PROOF STATE]
proof (prove)
using this:
(?s, ?t) \<in> S ^^ n O R \<Longrightarrow> (?s, ?t) \<in> R O S\<^sup>*
(s, t) \<in> (S O S ^^ n) O R
goal (1 subgoal):
1. (\<And>u. \<lbrakk>(s, u) \<in> S; (u, t) \<in> R O S\<^sup>*\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
(s, u) \<in> S
(u, t) \<in> R O S\<^sup>*
goal (2 subgoals):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
2. \<And>n s t. \<lbrakk>\<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*; (s, t) \<in> S ^^ Suc n O R\<rbrakk> \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
(s, u) \<in> S
(u, t) \<in> R O S\<^sup>*
[PROOF STEP]
have "(s,t) \<in> S O R O S\<^sup>*"
[PROOF STATE]
proof (prove)
using this:
(s, u) \<in> S
(u, t) \<in> R O S\<^sup>*
goal (1 subgoal):
1. (s, t) \<in> S O R O S\<^sup>*
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
(s, t) \<in> S O R O S\<^sup>*
goal (2 subgoals):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
2. \<And>n s t. \<lbrakk>\<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*; (s, t) \<in> S ^^ Suc n O R\<rbrakk> \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
(s, t) \<in> S O R O S\<^sup>*
goal (2 subgoals):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
2. \<And>n s t. \<lbrakk>\<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*; (s, t) \<in> S ^^ Suc n O R\<rbrakk> \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
have "... \<subseteq> R O S\<^sup>* O S\<^sup>*"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. S O R O S\<^sup>* \<subseteq> R O S\<^sup>* O S\<^sup>*
[PROOF STEP]
using push
[PROOF STATE]
proof (prove)
using this:
S O R \<subseteq> R O S\<^sup>*
goal (1 subgoal):
1. S O R O S\<^sup>* \<subseteq> R O S\<^sup>* O S\<^sup>*
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
S O R O S\<^sup>* \<subseteq> R O S\<^sup>* O S\<^sup>*
goal (2 subgoals):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
2. \<And>n s t. \<lbrakk>\<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*; (s, t) \<in> S ^^ Suc n O R\<rbrakk> \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
S O R O S\<^sup>* \<subseteq> R O S\<^sup>* O S\<^sup>*
goal (2 subgoals):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
2. \<And>n s t. \<lbrakk>\<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*; (s, t) \<in> S ^^ Suc n O R\<rbrakk> \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
have "... \<subseteq> R O S\<^sup>*"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. R O S\<^sup>* O S\<^sup>* \<subseteq> R O S\<^sup>*
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
R O S\<^sup>* O S\<^sup>* \<subseteq> R O S\<^sup>*
goal (2 subgoals):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
2. \<And>n s t. \<lbrakk>\<And>s t. (s, t) \<in> S ^^ n O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*; (s, t) \<in> S ^^ Suc n O R\<rbrakk> \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
finally
[PROOF STATE]
proof (chain)
picking this:
(s, t) \<in> R O S\<^sup>*
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
(s, t) \<in> R O S\<^sup>*
goal (1 subgoal):
1. (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
.
[PROOF STATE]
proof (state)
this:
(s, t) \<in> R O S\<^sup>*
goal (1 subgoal):
1. \<And>s t. (s, t) \<in> S ^^ 0 O R \<Longrightarrow> (s, t) \<in> R O S\<^sup>*
[PROOF STEP]
qed auto
[PROOF STATE]
proof (state)
this:
(?s, ?t) \<in> S ^^ n O R \<Longrightarrow> (?s, ?t) \<in> R O S\<^sup>*
goal (1 subgoal):
1. S\<^sup>* O R \<subseteq> R O S\<^sup>*
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
(?s, ?t) \<in> S ^^ ?n3 O R \<Longrightarrow> (?s, ?t) \<in> R O S\<^sup>*
goal (1 subgoal):
1. S\<^sup>* O R \<subseteq> R O S\<^sup>*
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
(?s, ?t) \<in> S ^^ ?n3 O R \<Longrightarrow> (?s, ?t) \<in> R O S\<^sup>*
goal (1 subgoal):
1. S\<^sup>* O R \<subseteq> R O S\<^sup>*
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
S\<^sup>* O R \<subseteq> R O S\<^sup>*
goal:
No subgoals!
[PROOF STEP]
qed |
[STATEMENT]
lemma \<Sigma>_incr_upper:
"\<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. \<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)
[PROOF STEP]
have "{l..<l+1} = {l}"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. {l..<l + 1} = {l}
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
{l..<l + 1} = {l}
goal (1 subgoal):
1. \<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
{l..<l + 1} = {l}
[PROOF STEP]
have "\<Sigma> f l (l + 1) = f (of_int l)"
[PROOF STATE]
proof (prove)
using this:
{l..<l + 1} = {l}
goal (1 subgoal):
1. \<Sigma> f l (l + 1) = f (of_int l)
[PROOF STEP]
by (simp add: \<Sigma>_def)
[PROOF STATE]
proof (state)
this:
\<Sigma> f l (l + 1) = f (of_int l)
goal (1 subgoal):
1. \<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<Sigma> f l (l + 1) = f (of_int l)
goal (1 subgoal):
1. \<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)
[PROOF STEP]
have "\<Sigma> f j (l + 1) = \<Sigma> f j l + \<Sigma> f l (l + 1)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<Sigma> f j (l + 1) = \<Sigma> f j l + \<Sigma> f l (l + 1)
[PROOF STEP]
by (simp add: \<Sigma>_concat)
[PROOF STATE]
proof (state)
this:
\<Sigma> f j (l + 1) = \<Sigma> f j l + \<Sigma> f l (l + 1)
goal (1 subgoal):
1. \<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
\<Sigma> f l (l + 1) = f (of_int l)
\<Sigma> f j (l + 1) = \<Sigma> f j l + \<Sigma> f l (l + 1)
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<Sigma> f l (l + 1) = f (of_int l)
\<Sigma> f j (l + 1) = \<Sigma> f j l + \<Sigma> f l (l + 1)
goal (1 subgoal):
1. \<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<Sigma> f j (l + 1) = \<Sigma> f j l + f (of_int l)
goal:
No subgoals!
[PROOF STEP]
qed |
module Rationals
isFactorInt : Integer -> Integer -> Type --Needed for defining Integer division
isFactorInt m n = (k : Integer ** (m * k = n))
divides : (m: Integer) -> (n: Integer) -> (k: Integer ** (m * k = n)) -> Integer
divides m n k = (fst k)
Pair : Type
Pair = (Integer, Integer)
Eucl: (a: Nat) -> (b: Nat) -> (Nat, Nat) --Euclidean algorithm implemented by Chinmaya
Eucl Z b = (0,0)
Eucl (S k) b = case (lte (S (S k)) b) of
False => (S(fst(Eucl (minus (S k) b) b)), snd(Eucl (minus (S k) b) b))
True => (0, S k)
gcdab : Nat -> Nat -> Nat -- Produces the GCD of two numbers. This will be useful to produce the simplified form of a rational number.
gcdab b Z = b
gcdab a b = gcdab b (snd (Eucl a b))
data NotZero : Integer -> Type where --Proof that a number is not zero, needed to construct Q
OneNotZero : NotZero 1
NegativeNotZero : ( n: Integer ) -> NotZero n -> NotZero (-n)
PositiveNotZero : ( m: Integer ) -> LTE 1 (fromIntegerNat m) -> NotZero m
make_rational : (p: Nat) -> (q: Integer) -> NotZero q -> Pair
make_rational p q x = (toIntegerNat(p), q)
InclusionMap : (n : Nat) -> Pair --Includes the naturals in Q
InclusionMap n = make_rational n 1 OneNotZero
AddRationals : (x: Pair) -> NotZero (snd x) -> (y: Pair) -> NotZero (snd y) -> Pair
AddRationals x a y b = ((fst x)*(snd y) + (snd x)*(fst y), (snd x)*(snd y))
MultiplyRationals : (x: Pair) -> NotZero (snd x) -> (y: Pair) -> NotZero (snd y) -> Pair
MultiplyRationals x a y b =((fst x)*(fst y), (snd x)*(snd y))
MultInverse : (x: Pair) -> NotZero (fst x) -> NotZero (snd x) -> Pair
MultInverse x y z = ((snd x), (fst x))
AddInverse : (x: Pair) -> NotZero (snd x) -> Pair
AddInverse x a = (-(fst x), (snd x))
Subtraction : (x: Pair) -> NotZero (snd x) -> (y: Pair) -> NotZero (snd y) -> Pair
Subtraction x a y b = AddRationals x a (AddInverse y b) b
Division : (x: Pair) -> NotZero (snd x) -> (y: Pair) -> NotZero (fst y) -> NotZero (snd y) -> Pair
Division x a y b c = MultiplyRationals x a (MultInverse y b c) b
--SimplifyRational : (x: Pair) -> NotZero (snd x) -> Pair
--SimplifyRational x a = (divides (gcdab fromIntegerNat((fst x)) fromIntegerNat((snd x))) ___ (fst x), divides (gcdab fromIntegerNat((fst x)) fromIntegerNat((snd x)) __ (snd x))
--Above, I will need to supply a proof that the GCD divides the two numbers. Then, the function defined above will produce the rational in simplified form.
|
function voxels = carveall( voxels, cameras )
%CARVEALL carve away voxels using all cameras
%
% VOXELS = CARVEALL(VOXELS, CAMERAS) simple calls CARVE for each of the
% cameras specified
% Copyright 2005-2009 The MathWorks, Inc.
% $Revision: 1.0 $ $Date: 2006/06/30 00:00:00 $
for ii=1:numel(cameras);
voxels = carve(voxels,cameras(ii));
end |
\documentclass{subfile}
\begin{document}
\section{BrNO}\label{sec:brmo}
\begin{problem}[$2018$, problem $9$]
Let $n\geq2$ be an integer. Prove the inequality
\begin{align*}
\dfrac{1}{2!}+\ldots+\dfrac{2^{n-2}}{n!}
& \leq\dfrac{3}{2}
\end{align*}
\end{problem}
\begin{problem}[$2015$, Day $2$, problem $1$]
Find all real number $x\geq-1$ such that the inequality
\begin{align*}
\dfrac{a_{1}+x}{2}\cdots\dfrac{a_{n}+x}{2}
& \leq \dfrac{a_{1}\cdots a_{n}+x}{2}
\end{align*}
holds for all positive integer $n\geq2$ and for all real numbers $a_{1},\ldots,a_{n}\geq1$.
\end{problem}
\begin{problem}[$2014$ Final Round]
Find all values $\lambda$ such that the inequality
\begin{align*}
\dfrac{a+b}{2}
& \geq\lambda\sqrt{ab}+(1-\lambda)\sqrt{\dfrac{a^{2}+b^{2}}{2}}
\end{align*}
\end{problem}
\begin{problem}[$2014$ Final Round]
Prove that for all positive real numbers $x$ and $y$,
\begin{align*}
\dfrac{1}{x+y+1}-\dfrac{1}{(x+1)(y+1)}
& < \dfrac{1}{11}
\end{align*}
\end{problem}
\begin{problem}[$2014$ Test $2$]
Let $a,b,c$ be positive real numbers such that
\begin{align*}
ab+bc+ca
& \geq a+b+c
\end{align*}
Prove that
\begin{align*}
(a+b+c)(ab+bc+ca)+3abc
& \geq 4(ab+bc+ca)
\end{align*}
\end{problem}
\begin{problem}[$2014$ Test $4$]
Let $a,b,c$ be positive real numbers such that $a+b+c=1$. Prove that
\begin{align*}
\dfrac{a^{2}}{(b+c)^{3}}+\dfrac{b^{2}}{(c+a)^{3}}+\dfrac{c^{3}}{(a+b)^{3}}
& \geq \dfrac{9}{8}
\end{align*}
\end{problem}
\begin{problem}[$2014$ Test $6$]
Let $a,b,c$ be real numbers in the interval $(0,2)$ such that $a+b+c=ab+bc+ca$. Prove that
\begin{align*}
\dfrac{a^{2}}{a^{2}-a+1}+\dfrac{b^{2}}{b^{2}-b+1}+\dfrac{c^{2}}{c^{2}-c+1}
& \leq3
\end{align*}
\end{problem}
\begin{problem}[$2013$ Test $3$]
Let $n\geq3$ be an integer and $x_{1},\ldots,x_{n}$ be positive real numbers such that $x_{1}\cdots x_{n}=1$. Prove that
\begin{align*}
\dfrac{x_{1}^{8}}{(x_{1}^{4}+x_{2}^{4})x_{2}}+\dfrac{x_{n}^{8}}{(x_{n}^{4}+x_{1}^{4})x_{1}}
& \geq\dfrac{n}{2}
\end{align*}
\end{problem}
\begin{problem}[$2013$ Test $7$]
Given positive real numbers $a,b,c$ such that
\begin{align*}
\dfrac{1}{ab}+\dfrac{1}{bc}+\dfrac{1}{ca}
& = 1
\end{align*}
Prove that
\begin{align*}
\dfrac{a^{2}+b^{2}+c^{2}+ab+bc+ca-3}{5}
& \geq \dfrac{a}{b}+\dfrac{b}{c}+\dfrac{c}{a}
\end{align*}
\end{problem}
\begin{problem}[$2012$ Test $1$]
Let $a,b,c$ be real numbers such that $0<a<b<c$. Prove that
\begin{align*}
a^{20}b^{12}+b^{20}c^{12}+c^{20}a^{12}
& < b^{20}a^{12}+c^{20}b^{12}+b^{20}a^{12}
\end{align*}
\end{problem}
\begin{problem}[$2011$ Round $3$]
Let $a,b,x,y$ be positive real numbers such that
\begin{align*}
ab
& \geq xa+yb
\end{align*}
Prove that
\begin{align*}
\sqrt{a+b}
& \geq\sqrt{x}+\sqrt{y}
\end{align*}
\end{problem}
\begin{problem}[$2011$ Round $3$]
Let $a,b,c,k,l$ and $m$ be positive real numbers such that
\begin{align*}
abc
& \geq ka+lb+mc
\end{align*}
Prove that
\begin{align*}
a+b+c
& \geq \sqrt{3}(\sqrt{k}+\sqrt{l}+\sqrt{m})
\end{align*}
\end{problem}
\begin{problem}[$2011$ Final Round]
Let $a,b,c$ be positive real numbers such that
\begin{align*}
a^{2}+b^{2}+c^{2}
& = 3
\end{align*}
Prove that
\begin{align*}
a+b+c
& \geq ab+bc+ca
\end{align*}
\end{problem}
\begin{problem}[$2011$ Test $5$]
Let $a,b,c$ be positive real numbers such that
\begin{align*}
\dfrac{a}{b+c}+\dfrac{b}{c+a}+\dfrac{c}{a+b}
& = 1+\dfrac{1}{6}\left(\dfrac{a}{c}+\dfrac{c}{b}+\dfrac{b}{a}\right)
\end{align*}
Prove that
\begin{align*}
\dfrac{a^{3}bc}{b+c}+\dfrac{b^{3}ca}{c+a}+\dfrac{c^{3}ab}{a+b}
& \geq \dfrac{1}{6}(ab+bc+ca)^{2}
\end{align*}
\end{problem}
\begin{problem}[$2010$ Final Round]
Prove that
\begin{align*}
\dfrac{a^{2}}{a+b}+\dfrac{b^{2}}{b+c}
& \geq \dfrac{3a+2b-c}{4}
\end{align*}
for all positive real numbers $a,b$ and $c$.
\end{problem}
\begin{problem}[$2010$ Test $1$]
Given non-negative real numbers $a,b$ and $c$ such that $a+b+c=1$. Prove that
\begin{align*}
\left(a^{2}+b^{2}+c^{2}\right)^{2}+6abc
& \geq ab+bc+ca
\end{align*}
\end{problem}
\begin{problem}[$2010$ Test $7$]
Prove that all positive real numbers $x,y$ and $z$ satisfy the inequality
\begin{align*}
x^{y}+y^{z}+z^{x}
& > 1
\end{align*}
\end{problem}
\begin{problem}[$2010$ Test $8$]
Let $a,b,c$ be positive real numbers such that $abc=1$. Prove that
\begin{align*}
\dfrac{a}{b(a+b)}+\dfrac{b}{c(b+c)}+\dfrac{c}{a(c+a)}
& \geq \dfrac{3}{2}
\end{align*}
\end{problem}
\begin{problem}[$2009$ Selection and Training Session]
Let $a,b$ and $c$ be positive real numbers. Prove that
\begin{align*}
\dfrac{1}{(a+b)b}+\dfrac{1}{(b+c)c}+\dfrac{1}{(c+a)c}
& \geq \dfrac{9}{2(ab+bc+ca)}
\end{align*}
\end{problem}
\begin{problem}[$2008$, Day $2$, problem $1$]
Let $x_{1},\ldots,x_{n}$ be non-negative real numbers. Prove that
\begin{align*}
\dfrac{x_{1}(2x_{1}-x_{2}-x_{3})}{x_{2}+x_{3}}+\ldots+\dfrac{x_{n}(2x_{n}-x_{1}-x_{2})}{x_{1}+x_{2}}
& \geq0
\end{align*}
\end{problem}
\begin{problem}[$2002$]
For any positive integers $a$ and $b$, prove that
\begin{align*}
|a\sqrt{2}-b|
& > \dfrac{1}{2(a+b)}
\end{align*}
\end{problem}
\begin{problem}[$2002$]
Given positive real numbers $a,b,c$ and $d$. Prove that
\begin{align*}
\sqrt{(a+c)^{2}+(b+d)^{2}}
& \leq \sqrt{a^{2}+b^{2}}+\sqrt{c^{2}+d^{2}}\leq \sqrt{(a+c)^{2}+(b+d)^{2}}+\dfrac{2|ad-bc|}{\sqrt{(a+c)^{2}+(b+d)^{2}}}
\end{align*}
\end{problem}
\end{document} |
State Before: Ξ± : Type u_1
Ξ² : Type ?u.12733
instβ : EDist Ξ±
x y : Ξ±
s t : Set Ξ±
d : ββ₯0β
β’ einfsep s < d β β x x_1 y x_2 _h, edist x y < d State After: no goals Tactic: simp_rw [einfsep, iInf_lt_iff] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.