Infoblog: Category Theory For Beginners: Fibrations and Lenses

Transcript

0:02

okay so how should I introduce this topic of vibrations

0:08

I could say something like vibrations are fundamental for understanding logic

0:14

and for understanding language and for understanding how mathematics is

0:20

structured I could say that vibrations appear all over category Theory to organize for

0:28

different concepts but that's not really why I made this

0:34

video the honest truth is that I just think that vibrations are very very beautiful

0:40

and so I wanted to make this video to introduce the ideas as simply as I can

0:46

because I think that vibrations are a funny thing the definitions involving

0:52

them are pretty abstract and because vibrations are so powerful

0:58

and because they involve so many things interacting it can be challenging to

1:04

wrap one's mind around the original definition of a vibration especially the

1:09

way that the topic is handled in a lot of books where one simply goes straight

1:14

to the definition and it's like okay I I've read the definition but I still

1:20

feel like I don't really understand what they are this kind of thing can happen

1:25

so I wanted to make this video to try and explain what vibrations are in an

1:30

intuitive sort of way and so I'm going to start very simply

1:36

and I'm going to sort of build up the levels of generality until we get to the

1:42

proper definition of vibration and along the way we're going to see how

1:47

vibrations interact with loads of things in category Theory and they always seem

1:53

to do it in a very visual way which I find really really Pleasant so to give a very simple example of a

2:01

vibration let's think about this case here where we have these two elements

2:07

here B1 and B2 and we have this set of elements over B1 one

2:16

two three and this set of elements four and five over B2

2:23

and so the idea here is that as we vary our elements in this set B

2:31

we have this sort of set which lies above that element and we call such a thing a fiber and

2:39

then what we can do is we can kind of change perspective and we can collect these fibers together

2:46

into this sort of Total Space that we could call E and then we can note that

2:53

there'll be a function from E to B which we can call P

2:59

which sort of recovers the information about these fibers in the sense that if

3:04

we look at an element of B and we look at the things that get sent to that under our function that will be the sort

3:11

of fiber over that element and so this is the basic idea we think

3:18

about some kind of a fiber which might be a set or more generally a category

3:23

that sort of Lies above something and it's a sort of variable fiber it varies

3:30

with the element in this base category B and then we sort of collect all those

3:35

fibers together and sort of glue them together to form this Total Space

3:40

and that comes with this map which is going to be a vibration or perhaps an OP

3:46

vibration we'll get to that later so this is the basic idea and in a sense

3:52

you can think of it as a sort of generalization of the idea of a function I mean a function is what I'm showing in

3:59

this example but we're going to get much more General now the thing is that so

4:04

many ideas in category Theory are organized in terms of these sort of vibrations and often when you look at

4:12

other data structures in logic or type Theory or even in language you find

4:18

vibrations there as well they seem to be a sort of natural way of organizing

4:23

things in layers and um it's really very interesting how this works

4:30

and we're going to encounter some extraordinarily interesting kind of

4:35

structures today so for example imagine that for every set we have a fiber over

4:44

that set and that is a category and for every function between sets we have a

4:52

sort of funk tour from the fiber category over one set to the fiber category over another set

4:59

so we have this immense amount of information and then we sort of attach it all together to form a giant category

5:05

and um it has this sort of projection functional back into the base space

5:13

these are the kind of structures that we're going to think about it's very very interesting and

5:18

the thing with vibrations is yes the

5:23

um the the definitions do get somewhat elaborate and in a sense what we do with

5:29

vibrations is to collect together lots of information into one big structure so

5:35

there does come a point in the sort of theory where all sorts of Concepts seem to emerge at

5:43

once and it can be a little bit overwhelming but once one sort of

5:49

adjusted to it it's really very easy to think about vibrations from that point on and it really gives one a new kind of

5:56

perspective on mathematics so it's very worth thinking about this

6:03

and so I really hope you enjoy this video now in this case here everything is very

6:08

simple our base space is just a set and our total space is just a set so as

6:15

we vary the elements in the base space the kind of fiber above that is just

6:22

going to be this set of elements that get mapped to that thing under p but notice that there are these two

6:29

different perspectives on what's going on here one of them is this kind of perspective where we've collected

6:35

together these two fibers here into this big kind of Total Space and we have this sort of

6:42

map that's showing us how these things are being kind of channeled towards

6:47

their different points in the bass space and the other perspective is to say that well we vary the thing in the bass and

6:55

as we do so this kind of set or Fiber above that changes

7:00

and so the basic idea of vibrations that we're going to look at today involves

7:06

this concept but also generalizations of it so we can ask things like what

7:13

happens when rather than this thing at the bottom here being a set maybe it's

7:18

actually going to be a category so perhaps these are objects in a category and maybe there's some arrows in this

7:25

category so in this case where B is a category so

7:30

in this case we might again have that there's a sort of set which is the fiber above B1 and there's a set which is the

7:37

fiber above B2 but also this Arrow F here in the base category will give us a

7:43

function which allows us to map things in one fiber to things in the other

7:48

fiber and so this is the basic idea actually

7:54

there's two different variants of this this is the case with what we call op vibrations and there's also

8:02

there's also something called vibrations where it turns out that these functions

8:08

go backwards we're going to encounter this later but this is the basic idea so the simplest case is where this kind of

8:17

function between these fibers goes in the same direction as the arrow that induces it

8:22

and this is an example of what's called a discrete op vibration but we can get

8:28

more elaborate than this because it could be that actually these fibers above these objects here are not just

8:37

sets maybe these fibers themselves are actually categories so instead of having a sort of indexed family of sets now we

8:44

have a sort of index family of categories or what's called an indexed category

8:50

and so this is a more elaborate scenario which is called an OP vibration and then

8:57

a vibration is the same kind of idea but where the um

9:02

the kind of funk tools induced by the arrows of the base category end up going

9:07

in the opposite direction and so these are the kind of ideas that we're going to come across now it's a very very

9:13

quick introduction to what's going on and I'm going to build up much more gradually and um you can see what's

9:20

going on incidentally um I started with this kind of simple example

9:26

where I just had everything was set and you can ask

9:32

is this the simplest kind of vibration and it's actually something a bit

9:38

simpler which is that what if all of these sets are either empty or hold a

9:44

single element so we have a situation like this and if you think about it what this is

9:50

really describing here like if we turn it into a a function so we say okay this

9:56

is our total space and we have a map like this this is our

10:02

projection P well what this is really giving us is a subset

10:10

right so when every fiber has at most one element

10:15

our vibration is just going to be sort of selecting a subset and so in a sense

10:23

that's the kind of simplest thing that we find so most of this video is about vibrations but if you stick with it all

10:31

the way to the end there's a nice little bonus which is that we're going to apply these ideas to talk about lenses now

10:38

lenses are used a lot in programming and computer science to handle these kind of situations where

10:45

we have two-way flows of information and it turns out that these ideas about

10:51

vibrations we're going to cover today are pretty adjacent to a really powerful

10:57

approach to think about all sorts of lenses and generalizations and these

11:02

kind of things have applications to the study of stuff like open dynamical systems and things like that so very

11:10

close to the end I'm briefly going to mention how some of these kind of vibrational ideas can be used to

11:17

understand some kind of very general perspective on lenses all right then so let's start

11:24

talking about vibrations with a really simple example so we're going to think

11:30

about dynamical systems so what we're going to do is we're going to think

11:35

about some funk tour that goes from some category into set now I'm going to pick

11:43

this category here I could really pick any category for the purposes of this

11:48

just cushion but I like dynamical systems so I'm going to pick this category here so what's this category

11:55

here then well it has one object which we'll just call dots and that has an

12:00

identity Arrow of course it also has this Arrow here which we call Sigma one

12:06

so that's just an arrow from so that's just the arrow from dot to Dot and if we

12:12

compose Sigma 1 with itself we get a sigma 2 and if we compose Sigma 1 with Sigma 2 we get Sigma 3 and if we compose

12:20

Sigma 1 with Sigma 3 we get Sigma 4 and so on so basically you can think of this

12:25

as just a sort of free monoid with one generator which is Sigma one so it's

12:31

basically just this simple idea where we have a category of one object which has an identity arrow and this Arrow Sigma

12:39

one and all of the sort of iterates of Sigma one

12:44

and what we're going to think about is a functor f from this category to set and

12:51

this is basically going to give us a dynamical system the way you can think of this is that this functional f is

12:58

going to send this object dot here to a set and it's going to send Sigma 1 to an

13:05

update function a function from that set to itself and then Sigma 2 is going to get sent to

13:12

the function we get by applying the update twice and so on

13:18

so this is the basic idea and let's just dive into an example so we could

13:25

consider this case here so um here's our

13:31

category B I'm just drawing it in a bit of a different way I'm only representing

13:36

Sigma 1 since what's going to happen to that really defines everything about this form tour and I'm drawing this dot

13:44

twice just because it looks nicer and so let's suppose that our thumb tool

13:50

then is going to send dot to this set of three elements one two and three and

13:56

it's going to send Sigma 1 to this function here shown in blue so this is

14:01

our sort of update function and so what this information really

14:07

means is pretty easy to convey with a picture like this okay so what we're

14:13

really saying here is that we have a sort of dynamical system the set of states is this set with members one two

14:20

and three and then our update function f of Sigma 1 is going to send State 1 to

14:27

state two state two to state three in state 3 to state two that's pretty much

14:34

all there is to it and it's pretty clear why this is called a dynamical system

14:40

so I've spoken about this idea a few times before but you might be wondering

14:45

well what does this have to do with vibrations and the answer is really kind

14:52

of hidden in plain sight because in a sense you're already sort of looking at a very simple example of one of these op

14:59

vibrations which is this sort of picture here this sort of State transition graph

15:04

that I'm drawing at the bottom but let me explain this a bit more carefully

15:10

so there's an idea that we've encountered before particularly in the video on representable thumb tools and

15:17

it's this idea of a category of elements and so that's the thing I want to talk

15:22

about next so what is the category of elements of f well it sort of looks like this picture

15:28

here a way that we can get it is by taking a look at this picture here of our Funk

15:35

tour and then we're going to sort of rub out these Bubbles and and we're going to

15:41

consider these sort of blue threads here to become arrows so let's call each of

15:49

them Sigma one because they're showing what happens when we do one update and there's a bit of bookkeeping here we

15:56

better record the sort of object that um these things were associated with in the

16:02

base category well there's only one object so we've got to put a sort of dot on here and what we have here is our category of

16:12

elements basically and so like we really have multiple

16:17

copies of the same object so we don't need to draw it like that we could simply

16:25

we could simply draw the situation like this we have three objects dot one dot

16:30

two and Dot three and then each of these arrows here is showing us what happens

16:36

when we do an update if this doesn't make much sense don't worry we're going to see other examples

16:42

of the category of elements and get at this idea more gradually but the basic

16:48

idea is that these kind of arrows here are showing

16:53

what happens to the different elements when we update them by

17:01

applying our front door to one of the arrows in the base category so we'll call each of these arrows Sigma 1

17:07

because they're showing what happens to our elements when we do one update now as usual with dynamical systems when we

17:15

think about them category theoretically there are more arrows that are going to be there there'll be Sigma 2 that

17:21

illustrates what happens when we do two updates and so on but we won't bother drawing those because they don't really

17:28

give us any new information they just sort of get in the way so basically you

17:33

can think of this picture here as the so basically this picture here

17:40

is a source of drawing of the category of elements of our functional f

17:45

and also this is going to come with this kind of projection function here

17:51

which um is basically just going to fold all of

17:57

this stuff back down onto the base category

18:03

so it's going to send each of these arrows to Sigma 1.

18:08

and so what we have here is this projection function P which goes

18:14

from our category of elements back to the base category and this is the kind of structure that we're going to be

18:21

mostly interested in now let me talk through a more precise description of the category of elements

18:32

and so here it is if we have a general function f from a

18:38

category B to set then we're going to have this category of elements which I'll write as e l of f

18:45

if I wanted to say what this is quickly I would say that it is the

18:51

slice category star slice F and if you don't know what

18:56

that is don't worry because I'll go over a recap of comma categories and so on

19:02

quite shortly but um here's an explicit description of this

19:08

category of elements so it has objects that correspond to pairs of an object B from this base

19:16

category script to be and an element X of f of B so remember F of B is going to

19:23

be a set because f is sending these objects of B to these sets

19:29

F of B so that's what the object of the

19:34

category of elements look like what about the arrows well an arrow from B comma X to B Dash comma x dash is just

19:42

going to be an Rog in the base category which has the feature that if we get this Arrow G in the base category and we

19:48

apply F to it so it becomes a function then that's going to send X to x dash

19:54

and so the sort of picture to have in mind is something like this we've got our base category B there's going to be

20:04

some objects in it like B and B Dash and probably some arrows like G

20:10

and then we have this functor F which goes from that

20:17

to set and so this B here is going to get sent

20:24

to some set F of b b Dash is going to get sent to

20:29

some set F of B Dash and so we're going to have some sort of

20:36

elements in here like we might have an element X in this set F of B and we might have some element x dash

20:44

um in F of B Dash and then also this function f is going to send this Rog to

20:51

some sort of function F of G which goes from F of B to F of B

20:56

Dash and then the idea to get the category of elements is we sort of rub out these

21:03

bubbles and then we're going to index these things properly so we recall that this x

21:10

here is associated with B and this x dash is associated with B

21:16

Dash and then we're going to have an arrow from

21:22

B comma X to B Dash comma x dash which is called G precisely when this x dash here is the

21:30

thing that we get by applying the sort of lifted functor on x so basically these kind of arrows

21:41

so basically these kind of arrows in this elements category of f

21:48

are indicating how different elements get converted to other elements under

21:54

the sort of lifted versions of amorphisms in the base category and there's also going to be this sort

22:00

of projection functional here p which takes these things in the category of

22:06

elements and it just sort of gives us the indexes for those things and that's going to be our projection functor and

22:13

this is our sort of quintessential example of a discrete op vibration okay

22:19

so I think the easiest way to introduce these op vibrations is to show you simple examples so let's suppose that we

22:27

have some functional f from some category B into set

22:33

and um I've picked this case where F really corresponds to a graph so just

22:40

for this example suppose that this category B has these two objects here EMV and these two arrows here s and t

22:48

and so when we apply this functional f e is going to get sent to an edge set

22:55

V is going to get sent to a Vertex set

23:00

s is going to get sent to this function which Associates each edge with a source

23:08

and T is going to get sent to this function which Associates each edge with the target

23:13

and so I've drawn an example graph F here at the bottom

23:19

and you can see that this functional F in this example um it's going to send the edge sets as a

23:26

set of two edges A and B and this Arrow s here gets sent to this function f of s

23:33

which is pointing every Edge to its source vertex and so on

23:39

so this is just the usual idea of a funk tool which goes into set

23:45

and then what we're going to do is we're going to get the category of elements of this functional and the simplest way to

23:52

think of this I reckon is you look at this kind of picture here

23:57

which is sort of showing us how the function works and then we're just going to sort of

24:03

change it a little bit so we're going to rub out these bubbles

24:10

and we're going to remember where our objects came from by sort of indexing

24:16

them so we'll put an e on the front of these because these came from E these get a v

24:22

on the front and then these arrows here that are sort

24:27

of showing us how our functions work again it become arrows in our category the red ones we're going to label with

24:34

an S because they were made by our source arrow and the green ones we're

24:40

going to label by a t and so now we have this category it has

24:45

four objects one two three

24:50

four and it has these four arrows uh two of them are called s

24:56

it's okay if we give them the same name because they have different sources and targets so we're not going to get

25:02

confused um and also we've got these two arrows called T and we're going to have some

25:09

identity arrows as well so in total we're going to have four identity arrows

25:14

two arrows called s two arrows called T and we're going to have four objects and this is our category of elements

25:22

of Alphonse or F and we'll call this e l of f

25:28

and so that's the basic idea and you can do an analogous thing when you have any phone tool from any category B into sets

25:36

so basically the way I think of it is you can draw your font or F by drawing

25:42

the sort of um bubbles which show the sets that you

25:47

know your object subscripted B get sent to then you can draw these threads that show you how these uh functions work you

25:55

know the functions you get by applying after the arrows of script TV well then

26:02

if you sort of rub out the bubbles and think of those threads as arrows that's basically your category of elements

26:09

and the important thing for us today is that

26:14

there's going to be a sort of projection Funk tour we could call P and it's just going to go like this it

26:21

basically just um remembers the sort of index

26:27

um so you know e comma a gets sent to e e comma b gets sent to e because you

26:32

know those two things are indexed by e of course these green arrows up above

26:37

gets entered a green arrow below and the Red Arrows up above gets sent to

26:43

the red arrow below so this is our functor p and this is going to be a fun tour from

26:49

our category of elements two-hour sort of Base category script to be here and this kind of functor p is

26:58

what we call a discrete op vibration and these are the kind of things we're

27:05

going to start by studying because they're pretty simple examples of op

27:10

vibrations so what we're going to need to set this up is this idea of this interval

27:17

category here this is just this category that has one Arrow between distinct objects together with

27:24

identity arrows so this is sort of I've sometimes I call this category

27:29

Arrow and so it's interesting then if we have

27:34

some category D we can form this category here so this is the category of funk tools from I to

27:42

D and this is sometimes called the Arrow category

27:49

of d now this it turns out is going to be pretty important for us it has lots of

27:55

nice connections with vibrations that we're going to see later um

28:03

what is this category explicitly well it has objects which correspond to arrows

28:09

so this F is going to be an object in this Arrow category as is this F Dash

28:15

and what's going to be amorphism from F to F Dash well that's just going to be a pair of arrows of d u and v which make

28:24

this Square commute here so that's the nature of this Arrow category

28:30

and there's something important about this Arrow category um most important for us is going to be

28:38

that there's this functional called Cod and it turns this Arrow category into a

28:44

fish no it it doesn't it it gives us the co-domain of the arrows so the way it

28:51

works is it's going to send this object F here

28:56

to y and it's going to send this object F Dash here to Y dash

29:03

and it's going to send this Arrow U comma V to V so that's how Cod works and in a

29:11

similar way there's another functor which is called Dom and that gives us the domain of stuff so

29:18

it sends F to X it sends this morphism to U and it sends F Dash to x dash so it

29:26

gives us the domain of everything another idea that comes up a lot in this video is comma categories so I thought

29:32

it's worth again quickly going through a definition of a comma category

29:38

so suppose that we have a couple of funk Tools R and S which both go into a

29:44

category D well then we can form the comma category R slice s or R comma s

29:52

and this is a very useful idea for us for example when R is this functional

29:59

that just creates a Singleton set and F is some other function to set well then in that

30:06

case this comma category um star slice f is actually our category

30:13

of elements so that's one reason comma categories are useful but how do we get

30:18

comma categories in general well if we have these fun Tools R and S then this comma category here well it's objects

30:27

consist of triples of an object a of big a and an object B of Big B and an arrow

30:34

F from R of a to S of B and then amorphism from one of these triples ABF

30:42

to another of these triples a dash B Dash F Dash is just going to be an r o m from a to a

30:50

dash and an arrow n from B to B Dash which have the property that they make

30:57

this kind of square commute when we do r on the m and when we do s on the m so

31:03

that's also quick introduction to comma categories sometimes I might write the comma

31:09

category like this just be a bit more explicit about where these Funk tours come from

31:17

so R slice s like that

31:24

um sometimes we might think about

31:30

the case where we have that the first film tour is an

31:36

identity from tour and the second Funk tour is

31:44

picking out some object d and that kind of thing is sometimes written as

31:51

script Ed slice Little D and that's sometimes called a slice

31:58

category and there's also the other idea kind of upside down

32:03

which would be like where it's the top front door that's picking out a single

32:08

object and it's the bottom Funk tour which is uh the identity

32:15

and that kind of thing is sometimes written as D slice scripty D and that's

32:22

sometimes called a CO slice category incidentally um this category here

32:30

identity of D slice identity d is actually equivalent to the category of

32:38

arrows of D itself so you see already that this concept

32:43

um is very very rich this concept of comma categories okay so this category of elements

32:50

interact with lots of other mathematical structures and in my opinion it has a

32:56

very kind of visual flavor and so it's very interesting to see this category of elements doing its thing because it

33:04

usually gives one a nice kind of visual perspective on different things in mathematics so here's another way to

33:12

think of the category of elements there's actually a few different sort of equivalent ways that one couldn't Define it and one of them is as this sort of

33:20

pullback square so this is a pullback in cats so remember cat has objects

33:28

corresponding to categories and arrows corresponding to Funk tools and so we can draw this kind of diagram here that

33:36

I'll explain momentarily and then we can compute the pullback of it now the way

33:42

that you compute pullbacks in cats is pretty much very similar to how you

33:48

compute them in sets you remember when your compute pull back in sets you're taking the

33:54

um the set of pairs of an element um from this set and

34:01

an element from this set

34:08

which have the property that if we apply F on the first element

34:14

then we get the same result as if we apply this function on the second

34:20

elements and so if you apply that same kind of

34:25

thinking to the objects of these categories then you get the set of objects of this category of elements and

34:32

you can see that you know an object in this category of elements is just going to consist of a b

34:41

and an X which is in F of B and also you can apply exactly the same

34:48

kind of reasoning for the arrows if you want to get the arrows of this thing you look at the sets of pairs of an arrow of

34:54

this and an arrow of this which have the feature that if we do this function on the Arrow from here we get the same

35:00

result as if we do this front door on the Arrow from here so that's a sort of

35:07

one minute recap of how we get pullbacks in cats but like what are we actually

35:15

doing a pullback of well this is just our functor F that we're sort of making

35:21

our category of elements from this thing here is what we could call the category of pointed sets so this has objects

35:32

which correspond to sets with distinguished elements and then the maps

35:38

are just these functions that preserve these um distinguished elements so there's

35:44

various interesting sort of equivalent ways to think of this category of pointed sets

35:50

um another way you can think of it is if you get the maybe monad on set and you

35:56

take the closely category of that that turns out to be equivalent to this category of uh pointed sets you can also

36:04

think of this as um the category of uh sets and partial functions that's again

36:11

equivalent um but there's clearly going to be this sort of forgetful thumb tool you here

36:17

which takes a pointed set and forgets the point and it turns out that if we do

36:22

this pullback we get the category of um elements and it's kind of interesting

36:28

because like there's some kind of if you remember from topos Theory this idea

36:35

that you'd have something like a a true value object

36:41

and um you'd have something like true and then you'd be pulling that back along f

36:47

you can see that there's something similar going on here with these categories of elements

36:53

um so that's kind of interesting but I won't go into that more now

36:59

okay so now I want to talk about something called discrete op vibrations now these sound complicated they sound

37:08

kind of um overly elaborate right it's it's not just a vibration it's it's not even a

37:15

discrete vibration it's a discrete op vibration so they sound kind of like something that you know is in the back

37:23

attic of mathematics but but actually these discrete op vibrations are super

37:29

important and they're some of the kind of simplest structures that we can use

37:34

to really understand what vibrations are all about so what is a discrete op vibration well

37:43

it's a funk tour that has certain properties and the basic idea is that

37:52

it works like the projection front door from the category of elements

37:57

so the basic idea is that it's a sort of abstract definition that's designed to

38:04

recover the thing that's happening when we take the category of elements of

38:09

something so the easiest way to understand what discrete vibrations are is just to think about the category of

38:16

elements so we'll come back to this proper definition momentarily but so okay to to introduce this idea of

38:23

discrete op vibrations let's think about the category of elements because really that's the main place where we get these

38:31

examples of these discrete vibrations in a sense it's it's the only place so

38:37

suppose that we have a funk tour f from beta sets we want to think about

38:43

the category of elements of f and let's call that e now what are the objects of

38:51

miscategory of elements well they're going to be things like this a pair of an objective our base category scripty B

38:57

and an element X of f of B so that's what the objects of this category of

39:05

elements look like now let's think about a particular question

39:11

suppose we have an Rog in this base category here

39:17

and what we want to know is are there going to be some arrows like let's call

39:24

an arrow Phi within this category of elements here which

39:32

are gonna come out of B comma X

39:40

and they're going to be such that they're going to get sent to g under

39:46

this projection function okay so this is the basic setup we start off with an

39:53

object in our category of elements let's call it e well we know that we can write it as B comma X

40:00

and so we know that this projection function is going to get going to send it to an object

40:07

we could equivalently call this P of E and then what we're going to do is we're

40:13

going to take a general Arrow G that comes out of P of e and we're going to

40:19

ask what are the arrows that get sent to g under this projection frontal

40:25

and the key thing to understand here is that if we say oh well Phi is such an

40:32

arrow well of course Phi is gonna have to get sent to some Target e Dash

40:39

um actually we can figure out what e Dash has to be right well at least we know that e Dash

40:46

is going to get sent on top of B Dash so we know that e Dash is actually going to have to have the form

40:54

B Dash comma x dash for some element x dash of f of B Dash

41:03

but we can do better why can we do better well actually if you think about

41:08

the way the category of elements works um the arrows in the category of

41:14

elements are actually sort of called the same things as the arrows in the category B

41:21

and in fact this projection functional kind of preserves those names so in a

41:26

sense we could say that Phi is going to be G and also we know that x dash here

41:34

is going to have to be a very particular thing it's going to have to be

41:43

f of G of x

41:49

and so what we find out and this is this sort of big Revelation is that actually

41:55

there's only a unique Arrow so there's a unique Arrow Phi

42:02

that has this feature that it's going to get sent on top of G so let me just reiterate what we've basically argued

42:10

here is that if we pick an object e in our category of elements

42:18

and then we pick an arrow G that comes out of P of e in our base category then

42:25

there's going to be a unique Arrow Phi which is in our category of elements

42:32

which has the feature that P sends it to that g and basically the reason for this is

42:39

because the arrows coming out of stuff in the category of elements

42:45

um are sort of defined by their Source object and what they get sent to in the

42:52

base category because you know then to find out the target object we're just sort of basically like applying a map to

42:58

an element now all of this might sound rather abstract and it kind of is

43:06

um but roll with it because it it really gives us a very nice bridge between two different things so basically what I've

43:12

just described is exactly the definition of a discrete of vibration so what we

43:20

basically do now is we say well okay let's just make this all a bit more

43:27

abstract so what we basically say is well we're not really caring now to say

43:34

that this category e is the category of elements

43:39

let's just suppose that we have some object e and now what we want to say is that

43:46

this category e comes with a functional P that goes to a category B

43:52

and it has the feature that if we take some Arrow G from PV

44:00

to some other thing let's say B Dash well then there's going to exist a unique Arrow Phi so something like this

44:15

foreign which has the feature that P of Phi

44:21

equals G okay and that's it it turns out that if

44:28

we look at things abstractly like that um that's kind of enough to

44:34

um specify that we're dealing with a category of elements so let's be a bit more precise about this now

44:41

um so I was just basically trying to motivate this definition which is our definition of a discrete alt vibration

44:48

so to be more precise then if we have a category e and a category b and a

44:57

functional P we say p is a discrete op vibration if and only if

45:02

for every object e within our category script e

45:09

and for every Rog from P of e to some object B Dash within our base category B

45:16

there's going to exist a unique Arrow Phi in E which has the feature that this

45:24

functional P sends Phi to G and what's the point of this definition

45:30

well the point of this definition really is that when this holds it turns out

45:36

that um basically we can find a functor

45:43

f from beta set which is such that we're going to have

45:50

that e is equivalent to the category of elements

45:58

of f and this uh p is going to turn out to

46:03

look like the projection functional that comes from that that's at least the kind of rough way that I usually think about

46:09

what discrete op vibrations are all about you know this is the the formal definition and the point somehow is to

46:18

kind of describe what's happening with the category of elements but a little bit more abstractly now we can be more

46:26

precise about now we can be more precise about how

46:33

discrete op vibrations relate to categories of elements um with this kind of result here

46:40

so what we can do then is we can actually Define a category of discrete op

46:48

vibrations and so again I'd I'd encourage you to

46:54

think of a discrete op vibration as like a category of elements with a projection function at least that's how I like to

47:02

think of them um but you know we can Define them in a

47:09

but you know they also we can also think of a discrete art vibration just as a functor that satisfies that

47:16

um rather abstract definition that I just went through and so that means that a discrete alt

47:23

vibration is basically a kind of font or something that goes from some category e

47:28

to some category B and you know cat has arrows as Funk

47:36

tours and if we consider cat slice B well they're not object of cats like B

47:44

um will be a funk tool that goes into a category B

47:50

so we could say that um this functor P here is an object of

47:56

cat slice B and so actually what we can do is we can Define the category of discrete op

48:03

vibrations of B it has objects as discrete op vibrations so

48:10

um this P here would be an object of um

48:15

of this category of discrete of vibrations so in particular we can Define this category D op fib and that's the

48:23

category discrete of vibrations of B and it's basically just the full subcategory of cat slice B on the objects that

48:31

correspond to these discrete vibrations so like this would be an object of

48:39

um cat size B so so like this would be an object in this category let's say

48:48

this is another object and then what would be an arrow from

48:55

this first object to this second object in this category here well it would just be a funk tour let's say h

49:03

which makes this triangle commute so p dash after H equals P that kind of thing

49:09

uh so that's what this category of discrete op vibrations of B looks like okay so now we've got all this stuff in

49:16

place we can talk about a very very interesting results

49:21

and what this result basically says is that

49:27

like if you have an object B and you're interested in the

49:33

category of funk tools from B to set well we've been interested in this kind of thing a lot right like we're

49:40

interested in stuff like dynamical systems and graphs and simplistual sets and

49:46

um we can think of each of those in terms of some particular frontal category well

49:53

it turns out then that um that kind of category which has you

49:58

know objects as functours and arrows As Natural Transformations that is actually

50:03

going to be equivalent to this category of discrete op

50:09

vibrations of B so this is very very cool what it's

50:15

basically saying is that like well we already know that if we take like a font

50:22

or F so an object in this category well then we can consider the category of

50:28

elements of f and that's going to come with this projection pump tool into B and this is

50:35

going to be a discrete odd vibration so we know that we can sort of send these Funk tools F over here to these discrete

50:42

art vibrations actually we can do this by doing this kind of elements uh

50:49

construction turns out that that's actually a funk tool from this category here to this category here but it's very

50:56

interesting that this is actually an equivalence of categories because it

51:01

it's kind of saying that if we're interested in studying these kind of things which are sometimes called

51:07

co-preciates you know these phone tools from some category B to set well it

51:12

turns out that basically the category of co-preceives of of B is equivalent to

51:18

the category of discrete op vibrations of B and so like

51:24

looking at things from the perspective of the elements category is sort of equivalent

51:31

um and that's very cool because like it it um it gives you a different

51:36

perspective on things a perspective where we have more categories and

51:42

um where we sort of well you know it's always useful when you have stuff like natural

51:48

Transformations and you're able to look at them in a different way and it gives you a different sort of perspective on

51:54

things and this kind of bridge does that for us too

51:59

so this is the result spelled out a bit more carefully

52:04

um what we're saying is that if we have this category of functions from B to set there's this funk tour from that to this

52:13

category of discrete art vibrations so like how does this function work well

52:19

it's going to send an object f of B comma set to the

52:26

category of elements of that which we could call El of f

52:32

I mean that's really going to come with this projection function as well um I kind of often prefer to write it as

52:42

star slice f but yeah um

52:47

that's basically what this function L is going to send F to what does this do to

52:55

the arrows in b-commerce set so an arrow in B comma set is going to be a natural

53:01

transformation Alpha from F to F Dash and that's going to get sent to this

53:08

phone tool here L of alpha and that's going to be like

53:14

a phone call from the category of elements of f to the category of elements of f Dash

53:20

and basically the way it works is kind of like if you just think about it for a

53:25

while and think about what you know um there's pretty much only one kind of

53:31

canonical choice that you you'd want to set up and it's basically you know we'll if we have an object of this category of

53:39

elements here that's going to be like an element X of f of B and if we just do

53:46

the beef component of alpha after that that gives us an element of f dash of B

53:53

and so this is showing us how L of alpha works on objects and the way it works on

53:59

arrows is basically it kind of it keeps the names the same basically so this is our

54:07

um sort of funkto which allows us to convert from these co-pre sheaves to

54:12

these discrete op vibrations and this is an equivalence of categories

54:18

so this is pretty useful because it kind of allows us to take a sort of elements

54:24

Centric or discrete op vibration Centric view to lots of things that we've been doing with these categories of frontals

54:32

and I'd argue that this is actually a pretty natural way to think about a lot

54:39

of um things that we've seen before so like it may seem like kind of abstract and

54:46

stuff but like think about the category of dynamical systems for example

54:52

so you know we have um this uh sort of free monoi with one

54:58

generator we have the category of funk tools from this into set and each of

55:04

those kind of fun tools corresponds to a dynamical system so for example this dynamical system here is like

55:11

um that would be like where we uh we do a front door from this into set

55:19

and this phone tool is going to send this object here into this sort of three

55:24

element set and this Arrow here is going to become this update function that

55:30

sends this left dot to this middle dot it's middle dot to this right Dot and this right dot to this middle Dot

55:38

um but the thing is like look at how okay so I should write it like uh like

55:45

this otherwise it's going to get confusing so this is set

55:52

and what we're really doing is we're sending this object here to this set here and this

56:00

Arrow here is going to become this update function the thing is though

56:06

um take a look at these pictures do these look like sets with functions

56:15

attached to them I'd say they look more like categories right like what we're really sort of

56:21

picturing here are objects and arrows which are showing how these

56:30

sort of objects are getting updated and so in a sense I'd say that what we

56:35

draw normally when we think about dynamical systems are basically these sorts of categories

56:41

of elements of these Funk tools and so in a sense we're already

56:47

picturing these discrete alt vibrations I mean really discrete op vibrations are

56:53

going to be things like um the category of elements of f which kind of looks like this I mean yeah there's more

56:59

information in the category of elements in the sense that we'd be drawing extra arrows which show what happens when we

57:04

do two updates three updates and so on but like you know um we just don't have to depict those if

57:12

we just show these arrows that show what happens when we do one update this is pretty much like a category of

57:19

elements and yeah okay like there's also this projection functional here which

57:25

will be folding us back onto our free monoid which we're sort of not drawing but you know that's okay

57:32

um basically I'd say that um it's quite natural to think of a lot

57:37

of these Funk tools that go from um some category B to set in terms of

57:45

these discrete op vibrations so yeah um I mean actually you know this goes even further so we could ask like what's

57:53

a morphism from this dynamical system here to this dynamical system here and you know the usual answer is well it's

58:01

just going to be like a natural transformation Alpha from F to G

58:06

but you know if we go from this category of co-pre sheaves

58:12

to the category of discrete op vibrations we get a kind of different perspective which is that

58:19

um really we can think of this Alpha as a sort of funk tour which goes from this

58:25

category here to this category here um and it's sort of

58:32

um works so that this kind of triangle commutes here and you know again I I kind of think

58:39

this makes quite a lot of sense um so in a sense we could say that what

58:45

we have here we could think of something happening in cats where we have a kind of commuting triangle like

58:52

this so yeah this is the sort of idea I'm trying to get across here it's that this way of converting from

58:59

um Funk tools from beta set to discrete old vibrations is important and

59:06

um like it's it's useful to sort of meditate on what this does to special

59:12

kind of funk tours so for example a special kind of fun tool from beta set is going to be a home phone tour

59:20

uh so what happens to a harmful when we do this category of elements thing well we get the category of elements of the

59:28

home phone tool of course and that comes with a projection but really this it turns out is equivalent to a little B

59:35

slice scriptdb and that turns out to be a pretty interesting sort of fact

59:41

um like another thing which is kind of interesting to think about is the your

59:49

needle Lemma so really the only dilemma is kind of

59:55

something that has to do with this category here of co-prechives but you

1:00:02

know using this kind of equivalence we can also now think of the yo needle Emma as something that has to do with

1:00:08

discrete op vibrations of B um so I'm not going to go through this

1:00:14

in in great detail you can check out the um the appendix I think it is of um

1:00:23

fosco's book co-end calculus um if you want to see more about this

1:00:29

but the um the basic idea is like this we

1:00:36

like the yo needle Emma basically says that um these kind of natural Transformations

1:00:43

Alpha from like a home functor into f are

1:00:48

in a sort of natural correspondence with their elements of f of B

1:00:55

and um you know we we know how this works but now we can say well okay this

1:01:02

is like an arrow in our category of co-priceives

1:01:07

what does it look like if we translate it in terms of discrete odd vibrations

1:01:14

and well you know we know that this home phone tool here is going to get sent to this category of elements and that ends

1:01:21

up looking like little B slash scriptdb so this ends up getting sent to this

1:01:27

and then Alpha gets sent to L of alpha and F gets into its category of elements

1:01:33

and so what we're really saying is that um this kind of natural transformation Alpha corresponds to this kind of

1:01:40

functor L of alpha which is like a amorphism of discrete up vibrations

1:01:47

and also like if you think about it um little B slice scripty B

1:01:54

is going to have a special object which is going to be this object which

1:02:00

is the identity Arrow of little B

1:02:05

and like that's going to get sent by L of alpha to a particular

1:02:13

um object in the category of elements and it's actually going to be this one here which is going to be

1:02:21

um basically the elements which sort of corresponds to Alpha

1:02:32

and it turns out that this element here is really the special elements of f of B

1:02:37

which corresponds to Alpha under the Yo needle Lemma so this gives you a sort of

1:02:44

different view of the yo needle Lemma in terms of discrete alt vibrations

1:02:50

um another thing I sort of can't resist mentioning but I'll try and mention it as quickly as possible because there's there's so much to go through but this

1:02:58

other thing was really the focus of my video on representable Funk tours

1:03:04

and um it's this very beautiful Resort which says that

1:03:09

um if we have a functional U from a category a to set then

1:03:15

um we're going to have a sort of representation of that which means that we'll have a special object a star and a

1:03:22

natural isomorphism Phi from um this home phone tool here which you know we could also write as like hom

1:03:29

subscribe to a a star comma blank

1:03:36

well we'll have a natural isomorphism Phi from this hom-funk door to you uh if

1:03:43

and only if the sort of element corresponding to Phi

1:03:49

um is going to give us an initial object in the category of elements of U and like look at my video on

1:03:57

representable Funk tools if you want to see this um unpacked in more detail but it's like

1:04:03

a really awesome result because for example this lets you understand

1:04:09

like loads of stuff about adjoint front doors so in particular suppose that we

1:04:15

have the L is the left adjoint of R so that means we have this kind of natural

1:04:21

isomorphism here so we have this Phi here which is um

1:04:26

a natural isomorphism from uh this function also this function well

1:04:33

this function on the right this is a functional from a to set we could call it U

1:04:39

and let's um we want to think about this as a representable funk tool so let's call

1:04:45

this thing here a star um

1:04:51

like this and then this equation here becomes this

1:04:57

so Phi is a natural isomorphism uh basically exhibiting you as a

1:05:05

representable functor in terms of this object a star and this natural isomorphism Phi and then the previous

1:05:12

result says that um this kind of element that sort of corresponds with Phi under the needle

1:05:19

Emma um you know we could call it Phi hat or Phi

1:05:25

of a star of the identity well this is going to be an initial object of

1:05:31

um the category of elements of U and we can write it like this we could write it like this we could write it

1:05:37

like this we have these different forms for the category of elements of U

1:05:43

and um what is this that we've just figured out

1:05:48

well it turns out it's actually just the unit of our redjunction

1:05:54

um so basically what this is telling us is if you have the kind of

1:06:01

natural isomorphism in terms of these home sets that's describing this

1:06:06

Junction you can use it to get the unit of Euro Junction and you can go the

1:06:12

other way as well so this is a very cool result um so I want to move on now to

1:06:20

sort of punch things up and go to a a higher perspective and look at a more

1:06:26

sort of elaborate vibration which um you know is not discrete anymore

1:06:33

um just one thing before we we move up a level is this other very interesting

1:06:39

result so you may recall that

1:06:44

um if you're working with the category of sets

1:06:49

you can always sort of factorize a function so

1:06:56

um let's look at a function

1:07:01

from one two three to ABC let's do this one here so we'll send

1:07:09

these elements like this now it turns out that we can we can factorize this so we can

1:07:16

factorize it into sort of two steps so firstly we're

1:07:22

going to do this um epomorphism here

1:07:34

and then we're going to do this monomorphism here so in this way we can factorize

1:07:43

any function f into an epomorphism followed by a

1:07:48

monomorphism um and so that's something that we can

1:07:54

do in the category set so we could ask what about cat

1:08:01

can we factorize arrows in cats is there a sort of special way that we can always

1:08:06

break arrows in cats into two different forms

1:08:12

and it turns out that there is um and so we have this very interesting

1:08:18

result and it's called the sort of comprehensive factorization of a funk tour so suppose we have a general

1:08:25

functional F from a category a to a category B well it turns out that we can always

1:08:31

write f as some function or w followed by a projection from a category

1:08:38

of elements so in other words we can always factorize any functor

1:08:44

through a discrete op vibration and um

1:08:50

how this works is sort of quite elaborate and there's quite some interesting

1:08:56

details behind this Construction um

1:09:01

and there's quite some interesting details behind this construction um the basic idea is that if you have a

1:09:07

functional F then you can find a functional k um and a functional W such that you can

1:09:15

do W and it goes to the elements category of K and then you can do the projection functional from that back

1:09:20

into B and that will give you your functional back so

1:09:27

I've added a video uh an unlisted video

1:09:32

so if you have a look at the description of this video um I've put a link to an unlisted video

1:09:39

where I talk about this result and how we actually do this construction it's

1:09:44

kind of involved so I thought I'd leave it out of the main video but it's a very interesting kind of construction that

1:09:52

involves interactions between can extensions and different perspectives on

1:09:58

comma categories and things it's a very interesting construction that I got interested in through this paper

1:10:05

um on vibrational Linguistics so it turns out that there's a way to think about like Linguistics in terms of

1:10:12

vibrations and then this kind of construction here turns out to be sort

1:10:19

of related to how people can understand each other when they use language at least that's what the authors of the

1:10:27

vibrational Linguistics papers propose Okay so we've got some understanding of

1:10:32

these discrete op vibrations what we want to do now is to sort of level up and think about

1:10:39

more General kinds of op vibrations so we're going to now look at one of the

1:10:45

most interesting constructions in category Theory which is called the grothendeek construction

1:10:52

and it's a really beautiful idea

1:10:58

um which basically allows us to attach together lots of structures in a

1:11:04

very kind of coherent way and really lets us organize all sorts of

1:11:09

knowledge so um I think the easiest way is if I just

1:11:16

introduce this idea directly and then I'm I'll talk more about some sort of motivations and ideas behind it later

1:11:25

so we want to talk about this grothendi Construction and the sort of main building block for

1:11:31

this is going to be a fun tour that goes into cats so now we're going to think of

1:11:36

f as a functional from a category B into cats so in a sense

1:11:44

the groffenheat construction allows us to organize the kind of data behind this funk tour into a single coherent sort of

1:11:52

structure in an analogous way to how the category of elements allows us to represent a

1:12:00

co-pre-sheaf so in a similar way the grothendi construction

1:12:05

gives us a category that represents a functoral like this F so in a way the most important thing is

1:12:14

what does a function f from a category B to cats look like

1:12:20

and the basic idea is that we're going to have this category B so

1:12:27

it might have objects like little B and little B Dash

1:12:32

and they might have arrows like G and so this would be a a part of our

1:12:38

base category B and then the idea is that this funk tour

1:12:44

is going to send this little b to some category

1:12:50

so this would be some category uh let's say this is uh F

1:12:56

of B and then also B Dash is going to get sent to some category so maybe it

1:13:01

looks like this this would be f b Dash

1:13:07

like so and also um this font or F is going to send the

1:13:13

arrows of B for example this Rog is going to get sent to a funk tour so

1:13:19

that'll be a funk tool from F of B to F of B Dash so that would be big F of little G

1:13:27

that'll be a funk door and so we sometimes call things like f of b or

1:13:33

F of B Dash fiber categories so we might call F of B Dash the fiber category over

1:13:42

B Dash and um

1:13:47

the idea basically behind the grafen D construction is that we're going to sort

1:13:52

of collect together all of this data here about these categories these fiber categories above these objects of B and

1:13:59

these Funk tools and in a in a very rough sense we're going to sort of rub out these Bubbles and think of what

1:14:06

we've got remaining as a kind of category and we can call this uh category e

1:14:13

keeping our naming convention or we could call it the graph Andy Construction

1:14:19

of this Fung tour f and it's pretty analogous to the construction for the category of

1:14:24

elements the main difference is that uh the sort of fibers above the objects of

1:14:29

B are not just sets they're now categories um and of course this thing comes with a

1:14:36

kind of projection functional P which goes into our category B and that is

1:14:42

what we call a op vibration so that's a sort of one minute introduction to

1:14:48

growth and deconstructions now let's go through the uh the details more

1:14:55

gradually so and so yeah the the idea is that we start with a funktor f from a

1:15:03

category B into cats and we can really think of such a thing as a sort of indexed category if we like

1:15:11

so think about a sort of category that varies as we change the object of B and

1:15:17

the arrows of B give us functions between these different fiber categories um so this is the data that we start

1:15:24

with and then the graph indeed construction is where we get that kind

1:15:29

of thing and we sort of glue it all together into a big category so the

1:15:35

setup is very similar to the way the category of elements is uh it basically

1:15:41

is the same as the category of elements except that we might have some sort of arrows Within These fibers and that

1:15:47

leads to some more elaborate structure so the objects of this growth and

1:15:53

deconstruction which is a category so grff-f is is a category called the graph

1:15:58

and deconstruction and it has objects which correspond to

1:16:04

pairs of an object in the base category B and an object X in the fiber category

1:16:13

above B so remember F of B here is a category and so an object in the growth

1:16:19

and deep construction of X consists of an object in the base category and an

1:16:25

object in the fiber category above that object

1:16:32

so for example um if we have a an object B

1:16:38

in the base category and object X in F of B then together that

1:16:47

pair of um B and X is going to be an object in this uh

1:16:54

graph Andy construction of f

1:17:03

and so that's what the objects of the graphene construction look like what about the arrows

1:17:08

so an arrow from um B comma X to B Dash comma x dash

1:17:17

consists of a pair and the pair is that we have and

1:17:22

consists of a pair and this pair is like well we have an

1:17:28

arrow G which goes from B to B Dash in the bass and then we have an arrow h

1:17:36

which uh goes from where X gets sent

1:17:41

by the kind of um substitution function

1:17:46

um f of G to x dash so

1:17:52

um an arrow in the Groff and deconstruction looks like a pair of arrows like this

1:17:57

the easiest way is me just to show you what this looks like in a picture so

1:18:03

um here's the kind of picture of it so what we're trying to picture here um just focus on this part of the

1:18:09

picture for now on on the left um and what we're trying to picture here is what an arrow from B comma X

1:18:18

to B Dash comma x dash looks like

1:18:24

in the um in this graph and deconstruction so we'll call this Arrow

1:18:31

G comma h and what it consists of is an RO G in

1:18:38

the base category that goes from B to B Dash together with this Arrow h

1:18:46

and this Arrow h goes from F of G of X so remember that F of G is a

1:18:53

funk tool so it's going to send X to um this um object FG of X and then we

1:19:02

want H to Be an Arrow from that destination to x dash so the way that I think about an arrow

1:19:09

like this um actually I like to think about uh Star Trek for this so I imagine that the

1:19:20

um the crew of Star Trek are trying to get inside some avian building which uh then

1:19:27

they can't transport into so the first thing they need to do is to teleport

1:19:33

from the ship to outside of the building and so um they have this kind of um

1:19:41

pad that controls the uh transporter and they have to put in the um the current

1:19:46

coordinates and the coordinates just outside of the building and this kind of Arrow here would be you

1:19:54

know how you can relate the two things inside a program that you put into the

1:19:59

um transporter mechanism in the starship

1:20:04

um and then when you sort of apply this phone tool here um

1:20:10

this allows them to transport from their current location to the location in the planet so this

1:20:18

function f here is sort of translating the um information on the transporter to

1:20:25

actual movement from the current location of Starship to the location on the planet but then once we've

1:20:30

transported down onto the planet they're still outside of the location that they have to get to so they have to do this

1:20:37

Arrow H which is like moving on foot so it's the kind of idea like um once

1:20:43

you've um once you've moved somewhere near your destination you have to do a

1:20:49

kind of secondary stage of the journey where you kind of um have to you know walk the last bit

1:20:55

this kind of you know Drive near to the location then walk the last bit so that's what an arrow

1:21:03

um looks like in this graph and deep construction to be a bit more precise it just consists of an Rog in the base

1:21:10

category paired with an arrow H from F of G of x to x dash

1:21:17

and so this is the basic idea um and hopefully you can see that the

1:21:24

category of elements is really like a special case of the graph and deconstruction

1:21:30

um so in particular um before what we were dealing with were

1:21:38

these phone tools which went from

1:21:45

a category B to set and then um

1:21:50

if we just sort of did an inclusion from set into cats which we can do because

1:21:55

like every set can be thought of as a discrete category so if there's this

1:22:01

kind of inclusion formed all from setting to cat we should send every set to the corresponding

1:22:07

um category that has that same set of objects but only identity arrows

1:22:14

well if we compose these and then we cook up the grafen D

1:22:19

construction of um this kind of funk tour so if we

1:22:24

basically consider the graph and deconstruction of I after F in this case

1:22:30

that's going to look like the elements category of F this is the basic idea

1:22:36

um but anyway going back to talking about the growth

1:22:43

and deconstruction more directly I've now told you what the objects are and

1:22:48

what the arrows are of course I still need to tell you the other two things that you need to know which are about

1:22:56

identity arrows and composition so what about identity arrows

1:23:01

so we if we have an object in the graph and deconstruction say B comma X

1:23:08

then how can we find an identity Arrow of it well we want an arrow from B comma

1:23:13

X to B comma X and we know that that's going to be a pair G comma h

1:23:21

and so since we want an identity Arrow let's pick G here to be this um

1:23:29

identity Arrow of B

1:23:37

and then we know that we want um

1:23:48

we want H to have this kind of form but you know we know that this G is an

1:23:55

identity Arrow so this is just going to be X here and so why don't we just pick H to be

1:24:03

the identity of x so yes this is what the identity arrows

1:24:09

of um over graph and deconstruction look like they're just pairs of identity arrows

1:24:19

the way that composition works is a bit more interesting so I'm trying to illustrate how

1:24:27

composition works with this picture here so let's look at this a bit more um

1:24:32

explicitly so suppose that we have a couple of arrows

1:24:39

in this graph and deconstruction so G comma H and G Dash comma H dash and we

1:24:45

want to compose them so let's say that this is their composition

1:24:50

so the composition again is going to be a pair of arrows the first Arrow we just want something

1:24:56

that goes from B to B dash dash in the base category and of course we're going

1:25:01

to take uh G Dash after G the second thing is a bit more

1:25:06

interesting so we also want to get the sort of second entry of this Arrow which

1:25:13

is this composition here and what we want this to do is we want

1:25:19

it to go from G Dash after G

1:25:29

lifted by f apply to X we want it to go from that to

1:25:36

x dash dash that's the form that we want H bar to take

1:25:42

and the question is really like how do we cook up this H bar and the answer is basically shown in

1:25:50

this picture here so what we do firstly we know that we have this Arrow

1:25:58

G comma H so that consists of this data and this data here now if we do F of G Dash on this Arrow H

1:26:07

that'll give us this Arrow here

1:26:13

and um if we compose that with this Arrow H dash

1:26:18

which um you know we get from this sort of second leg here

1:26:24

um then indeed that composition has the appropriate form and that's what we Define H bar to B so that's how

1:26:32

composition Works in this graph and deconstruction so I've now given you the full definition it's a lot like I think

1:26:39

when you first see it but I encourage you to look at some examples right like it's

1:26:47

it's quite easy to think of funk tools that go from some category B into cat

1:26:56

and then you can start con start doing graph and deconstructions of them and if you do a few of these examples

1:27:03

like you'll start really getting into it I think because it really is a very

1:27:09

beautiful kind of construction where you're um attaching together all sorts of

1:27:15

structure and um yes it's very interesting so

1:27:22

the other important thing to say about the growth indeed Construction

1:27:27

for us today is that it comes with a projection functor

1:27:35

and that's going to be a funk tour which goes from this Gruff and deep construction to the base category

1:27:43

and it kind of works in a similar way to the case with the category of elements

1:27:49

so in particular if we have an object in this graph and deep construction that's going to be like a pair B comma X

1:27:57

and p is going to send this to the object B

1:28:02

and if we have an arrow in the graph and deconstruction say G comma H which goes to B Dash

1:28:09

comma x dash well that's going to get sent as you probably guess to this Rog from B to B

1:28:17

Dash and that's it this is um

1:28:23

probably one of the um and that's it this is one of the big

1:28:29

ideas in category Theory this idea of a graph and deconstruction

1:28:34

okay then so now we know what grothendi constructions are

1:28:41

let's take a look at an example of one so this is

1:28:51

so this is a nice example that we're gonna look at again later

1:28:58

and basically what's going on here is that we've got a particular functor from our category B into cats and we've got

1:29:06

this and this is our front door f so here B can be any category that we

1:29:12

like and we're going to make a very particular Funk tour from being to cat

1:29:19

and basically it involves forming these slice categories so what we want to do

1:29:25

is we want to send the objects of B to categories in particular we want to send

1:29:30

little B to this category here which is scripty B slice B

1:29:36

so we're basically sending an object B to the category where we get by slicing

1:29:43

using that object it'll be and then if we have an arrow G then

1:29:50

that's going to get sent by F to this funk tour here

1:29:55

and the way this function Works which I'm calling this functional B slice G the way it works is that if we have an

1:30:03

object in this uh slice category here that would be like an arrow say from

1:30:08

some A to B well then this function is going to send that to this Arrow G after

1:30:16

e and it basically leaves the morphisms in these slice categories having the same

1:30:23

name so that's how this function works so basically

1:30:30

this is going to be F of B is this slice category and this fun tool here is going

1:30:36

to be F of G and it basically works by taking the objects in this slice category which are

1:30:44

really arrows into little B and then post composing those Arrows with G to

1:30:49

get objects in the slice category B slice B Dash

1:30:56

so that's how this funk tool works and then the interesting thing is that

1:31:03

when we do the graph Andy construction on this function f

1:31:09

we get something pretty interesting we actually end up getting the arrow

1:31:14

category of B um and I'll leave it to you to work out

1:31:21

the details about it's a great exercise that'll help you to understand a lot about growth and deep constructions

1:31:29

and um of course this Groff and deconstruction comes with its projection

1:31:34

Funk tour back to the base category and it turns out that that ends up being the

1:31:39

sort of co-domain funk tool that we talked about before that sort of sends these arrows these objects of uh I comma

1:31:48

B to their co-domains and so this is the sort of op vibration

1:31:54

which we get it's the funk tour that sends

1:32:00

our Arrow category uh of B to B Itself by getting

1:32:07

co-domains and so the sort of other way you can think about this is that like yeah we

1:32:15

have this funk tour uh from

1:32:21

B to cart and you know it's kind of like an indexed category it's like we're varying the object of B and we're

1:32:28

getting this slice category but you know if we sort of do the graph and deconstruction of f we're really

1:32:34

sticking all these slice categories together and that's going to give us this Arrow

1:32:39

category and that's going to be sort of like our total category our total space and then the kind of projection Funk

1:32:47

tool that goes back into B um is really sending every uh Arrow to

1:32:54

its co-domain and if we think about this situation here like if we picked a

1:33:00

particular object B and then we looked at the stuff that get sent on top of

1:33:05

that b by this code domain function that would look like this kind of fiber

1:33:11

category above B which is the um the slice category right because this

1:33:17

has objects that consist of arrows that go into B they're the objects which of

1:33:22

this category of arrows which which have codomain B so this is a really nice example to

1:33:29

study and get a lot of intuition about how

1:33:35

Gruff and D constructions work now what we're going to do next is sort of

1:33:43

um rocket boost a bit and get a bit abstract because suddenly loads of ideas

1:33:52

um come at the same time so this is a bit like I think this is a bit the the issue

1:33:58

of learning vibrations it's the the ideas are almost too good like

1:34:05

um so many things come at the same time that it's it can get a bit uh you can

1:34:10

get a bit much um so if you just stick with it after we've

1:34:16

gone through these main ideas we're going to slow down and look at some examples and then things will get more

1:34:22

clear but let me sort of um get a sort of higher level perspective

1:34:29

so one thing that we were doing earlier on was we were noting that

1:34:36

um we have this sort of equivalence between co-pre-shives of B and the discrete op

1:34:42

vibrations of B and now what we're doing is we're sort of generalizing everything

1:34:49

so rather than looking at these um phone tools here from beta sets we could

1:34:57

really think of them in a sense as Funk tools from B to cats that send uh the

1:35:03

objects of uh B to discrete categories if we like that you know

1:35:08

um working with discrete categories is kind of like working in set right so

1:35:14

um basically I'm saying that this category here um well it can be included in the

1:35:21

category of funk tours from B to cat right this is sort of more General thing

1:35:27

and if we have this then it turns out that we have something that this is

1:35:33

equivalent to and this okay this is not really true but uh just to say

1:35:38

approximately uh this is sort of equivalent to the category of

1:35:45

what we call op vibrations of B now there's a bit of a caveat here

1:35:53

that I'll I'll get into um but basically the idea here is that we're generalizing this structure here

1:36:00

on the left and we're going to do a sort of corresponding generalization of our notion of discrete op vibrations and

1:36:08

this is going to give us the idea of something called an OP vibration

1:36:14

um the basic idea is that um this grothendi Construction

1:36:21

um okay so the idea basically is that the elements category is to discrete op

1:36:29

vibrations as the graph and deconstruction is the op vibrations so

1:36:35

we're sort of generalizing everything and so this is really the um

1:36:42

the the big idea is this the big idea is this little picture here so um

1:36:51

basically

1:36:57

what we can do is if we have a funk tour from uh B into cat we can do a graph and

1:37:04

deconstruction on it um and we get this you know we get this

1:37:09

category called uh so if we have an F here we get this category called uh gr

1:37:15

of f and it comes with this projection functorin to be and it turns out that

1:37:21

this is always going to be something called an OP vibration and basically we have a sort of

1:37:29

equivalence where um these kind of op vibrations

1:37:36

um end up corresponding to these Funk tours from beta cat now here there's a

1:37:41

bit of a caveat that I I kind of don't really want to get into at this point because I don't think it's I think it's

1:37:47

a bit of a distraction but um it turns out that actually to get

1:37:53

this equivalence we want to have something a bit a bit more General than

1:38:00

just a funk tour from B to cat um it turns out that there's something called a pseudo-functor which is sort of

1:38:08

like a generalization of a funk tool so when you have a funk tool that goes into a two category like I mean cat we can

1:38:16

really think of cats as a two category right because it has these two cells that are natural Transformations well

1:38:23

when you have like a funk tool that goes into a two category you can kind of generalize that notion to get something

1:38:28

called a pseudo-funk tour and the idea with a pseudo-function like very roughly

1:38:33

is that you sort of generalizing things so ordinarily with a with a funk tour

1:38:41

uh it has to preserve composition exactly right so we've got to get that it's going to send the composition of G

1:38:48

and G Dash exactly to the um you know we're gonna we have to have

1:38:55

exactly the the um image of the composition is the composition of the images

1:39:03

and also the the um

1:39:09

the image of the identity arrow is the identity Arrow of the image

1:39:15

but you know with a pseudo Funk tour we don't require these kind of identities

1:39:22

to hold exactly we allow them to hold up to a sort of

1:39:27

um invertible to cell um in the the Target in this case cat

1:39:35

um and these sort of two cells which tell us how the um

1:39:43

you know how these laws you know almost hold um the sort of fiddle factors if you

1:39:49

like have to satisfy certain coherence conditions that I'm not going to get into

1:39:54

um at the moment if you have a look at the handbook of uh categorical algebra

1:40:01

um volume one uh chapter seven um these ideas are all explained there

1:40:08

um but basically it turns out that um there is a notion of op vibrations of

1:40:15

B and it's kind of like a a generalization of the notion of discrete

1:40:21

op vibrations of B so remember if we have like a general functor P from E to

1:40:27

B um there's certain conditions under which uh that kind of thing can be

1:40:33

regarded as a discrete of vibration well it turns out that

1:40:38

um there's also kind of more General conditions under which such a funk tour

1:40:44

can be regarded as an OP vibration and so we have a category of op

1:40:50

vibrations and it's it's again it's this uh subcategory of cat slice B it's a

1:40:57

full subcategory of it on the funk tours uh of this kind of form which satisfy

1:41:03

the conditions of being op vibrations and I'll give you a definition of up

1:41:09

vibration very shortly um so the idea basically is not that

1:41:14

complicated it's just that we have the situation from before and we're sort of

1:41:20

generalizing both sides so we're generalizing from discrete art vibrations to something called op

1:41:26

vibrations on the right hand side and on the left hand side rather than looking at these um co-preciaves we're looking

1:41:34

at these pseudo-functals into cats so I think this is the category that has a

1:41:40

objects as pseudo-functals into cats and arrows is a pseudo natural

1:41:46

transformations which are like natural Transformations but rather than like having the

1:41:53

commuting squares exactly there's these like invertible two cells of cats which

1:41:59

um which which do the job um so I'm trying not to get into the details of this

1:42:05

um too much but I wanted to sort of explain this uh very beautiful idea because really the point of this in my

1:42:14

opinion is that um it's kind of like you know how with

1:42:19

the discrete up vibrations like I was saying like really the key is this idea

1:42:25

of the elements category um and yeah there's some elaborate definition of when a funktor into B is

1:42:32

considered a discrete up vibration but really the point is that that definition is to

1:42:39

um is to sort of tell you when something looks like an elements category and in a

1:42:45

similar way an OP vibration is kind of like something that looks like a

1:42:51

projection from a gruffin date construction it's just that that growth and deconstruction can be um

1:42:58

it can be like based on a pseudo front door so okay that's a lot of information like

1:43:05

the point really is just that we're generalizing this to this and we're generalizing this to this and now I'll

1:43:12

tell you what this is so I'm going to now tell you what the definition of an OP vibration is

1:43:19

and here it is so well we're going to start explaining

1:43:25

what it is um why is this relevant

1:43:31

well I mean it's relevant because this is a very nice structure but also like

1:43:37

the title of this video is vibrations right and now I'm gonna give you a

1:43:43

definition of an OP vibration and basically we're going to see very shortly that we can just dualize

1:43:49

everything that we've done and we're going to get this kind of picture here

1:43:57

um so the Dual notion but not vibration is a vibration and everything's going to

1:44:03

um everything's gonna work out so really the main um thing that we have to do now is just

1:44:09

to understand what an OP vibration is and then pretty much everything and then

1:44:16

pretty much will have all the knowledge we need to understand lots of things about about these structures so what is

1:44:22

an OP vibration well before I Define that I want to define something else which

1:44:28

we're going to need and that's the idea of a co-cartesian morphism

1:44:35

so here's the idea suppose that we have a

1:44:41

functor p from some category e to B now

1:44:46

you should probably think of e as um like the Groff Andy construction of some

1:44:53

function f so this is like our total category but you don't have to let's

1:44:58

just think about this abstractly so this is just a definition we're saying that

1:45:03

we have a functional P like this and now we also have an arrow

1:45:09

Phi which is in this total category e here

1:45:15

it's in this category e which we could call Total but so now we have this Arrow

1:45:20

Phi which is in this category e and what we're saying is that under certain

1:45:26

conditions this Arrow Phi is considered to be something called Co Cartesian

1:45:33

and um it's called co-cartesian when uh

1:45:39

this stuff here is true so what's this stuff here saying well

1:45:45

what it's saying is that

1:45:50

when we have any kind of PSI which in some sense is

1:45:55

similar to Phi in a sense it has the same source and also when we have any G

1:46:02

which has the property that

1:46:07

if we do G after P of Phi

1:46:13

that gives us P of PSI well in that case

1:46:21

well in that case there's going to exist this unique Arrow

1:46:28

Chi which has the properties that P of chi

1:46:33

is G so it's getting sent to G and also that it makes this triangle commute so

1:46:41

it gives us a sort of way to emulate this um phonero PSI here

1:46:49

and that's it and that's the definition of when this kind of fire here is Coke

1:46:55

Cartesian so um I'm just going to push forwards and

1:47:03

finish the the definition of an OP vibration now so now we have this idea of co-cartesian

1:47:10

under our belts or at least you know now we're seeing the definition we can Define what a op vibration is so an OP

1:47:19

vibration now is going to be just a funk tour from some category e to some category B and

1:47:27

it has to have the property that if we pick any object of e and any Arrow

1:47:34

coming out of P of E then there's going to exist a unique

1:47:39

co-cartesian morphism with respect to P that gets

1:47:45

sent to that Ro F that's it that's our definition and um

1:47:53

so that's our definition of an OP vibration and now we have this category here op

1:48:00

FIB of B is just going to be like the the full subcategory of cat slice B on

1:48:06

the op vibrations and you can see that discrete op vibrations are special kinds of

1:48:12

um of vibrations much like the um elements

1:48:17

category is like um a kind of special case of a graph and deep Construction

1:48:23

um and so hopefully this picture now is starting to make sense

1:48:31

so um now we have all this lovely structure

1:48:37

let's just um dualize things and here's where we go from op

1:48:43

vibrations to vibrations so

1:48:50

honestly like there's a couple of things to say here like

1:48:56

um I think that op vibrations are simpler because they

1:49:04

don't involve contravariance so much so um for example here we have a covariant

1:49:11

from Tool from beta cat here we have a covariant front or from B to set

1:49:16

um op vibrations or like that they they involve these covariant front tools which basically makes them simpler

1:49:23

on the other hand vibrations which are the sort of Jewel of the concept we've been looking at so

1:49:30

far a more abundant in mathematics and

1:49:35

in some sense you could say that they're more important for category Theory

1:49:42

so it's going to be very worthwhile to understand how we can get to the idea of

1:49:48

vibrations now basically in some sense it's pretty

1:49:54

simple we're just looking at the Jewel of the notion but since what we have

1:49:59

here is some fairly complex machinery uh the way that this Duality Works can

1:50:05

get a bit elaborate so I'm going to spend the next few minutes describing how we can kind of use Duality to go

1:50:13

from this picture of op vibrations to the picture of vibrations

1:50:18

and after that I'm going to sort of stand back and um look at vibrations from their own

1:50:26

perspective and at that point things will get a lot simpler and

1:50:31

um we can look at like vibrations which have really been the the uh Target of

1:50:37

this video all along really because they provide a great deal of um

1:50:43

a sort of organizational power so we want to dualize this stuff

1:50:51

so we want to dual eyes the notion of a op

1:50:56

vibration let's start with that

1:51:05

so the Jewel of the notion of an OP vibration is something called a

1:51:10

vibration and so what we say that a functor p from

1:51:15

E to B is a vibration if and only if the opposite of that functional so we could

1:51:22

call that P op is an OP vibration and what's the opposite of a functor

1:51:28

I'll remind you if we have a functional P from E to B then it's opposite

1:51:35

well it's going to go from e-op to B op it works the same way as P worked on

1:51:43

objects so it sends e to P of e and so on but um if we have an ROK in our original

1:51:50

category e then we're going to have an arrow K op in EOP and what's going to happen to that under

1:51:57

our funktor P op well it's going to get sent to the opposite

1:52:04

of P of K so this is how P op works it basically

1:52:11

um sort of works the same way as P but you

1:52:16

know the arrows are all reversed that it's mapping um

1:52:21

so this is the idea of the opposite of a funk tour and the idea is that

1:52:27

um this functional p is going to be a vibration if and only if it's opposite

1:52:33

is an OP vibration so that's kind of enough and now we can start to look at a

1:52:40

picture like this which is sort of analogous to the picture we were looking at before but it's the kind of Jewel of

1:52:46

it so what we have at the bottom right here is this category of vibrations

1:52:52

and so if we have a function E from

1:52:59

P to B it may be a vibration and it'll be a

1:53:04

vibration if and only if it's opposite

1:53:12

is an up vibration but you know you can um you can get the conditions for p to

1:53:19

be a vibration directly um vibrations are also called growth and

1:53:24

deak vibrations so if you have a look at ncat lab there's a nice page which gives

1:53:30

you a sort of explicit definition of what a vibration is

1:53:36

and um you know you can talk about them in terms of Cartesian morphisms which are the sort of jewels of

1:53:43

cocartesiomorphisms and so on um so we kind of can understand what uh

1:53:49

vibrations are and then this category FIB B is just going to be the the full

1:53:55

subcategory of cat size B on the objects which

1:54:00

correspond to these vibrations so that's what these things are

1:54:05

what's going on in this picture at the bottom left well that's pretty self-explanatory these are just Funk

1:54:11

tours from B op to cat now the interesting thing here one one

1:54:17

sort of interesting thing is how do we get from a functoral from B op to cat to

1:54:22

a vibration and to do that we have to do something called a contravariant growth

1:54:30

and deconstruction so this is a little bit funny when one

1:54:36

first uh encounters it so the idea is basically like this

1:54:42

we've already seen uh something that I've been calling the Grothe Construction

1:54:48

I should really call this the covariant

1:54:53

growth and deconstruction and notice I'm writing g r of f to denote the growth

1:55:00

indeed construction here um now actually this is not the normal

1:55:08

um thing that people mean when they talk about graph and deconstructions much like vibrations

1:55:15

are more popular than op vibrations there's a sort of contravariant version

1:55:21

of the graph and deconstruction which is kind of more popular in a way so for the

1:55:27

contravariant version of the graph and deconstruction what we have

1:55:32

is we have a funk tour from biop

1:55:38

to cats and most people would say that's a contravariant phone call from beta cat

1:55:45

and given such a thing we can construct a category which we call Gro

1:55:53

of f and this is the so-called contravariance

1:55:58

gross and deconstruction and it comes with a projection P which is going to be

1:56:04

a funk tour which goes into the category B so like warning here this is not the

1:56:11

same thing as the um as the covariant graph and deconstruction when one first sees this

1:56:19

kind of thing one might think oh well I'll just look at this funk tour I'll just Define

1:56:25

um a category a which is equal to B op so now I have a function f from a to cat

1:56:31

and I'll do the covariant graph and deconstruction that we already know on this phone call from a to cat if you do

1:56:38

that you won't get this this is something different okay

1:56:45

um you can see that because like if we did this construction here um well we'd end up with like the graph

1:56:52

and D construction of f and that would come with this projection

1:56:58

function into a but actually we want a projection function into B which is not

1:57:04

the same thing so yeah this is something new basically

1:57:09

this is something new this is the contravariance graph and deconstruction

1:57:15

um if you have a look at this paper um I found this paper very useful in preparing for this video uh generalized

1:57:21

lens categories via font tours this does a really great job of explaining the

1:57:27

um this sort of um difference and how you can convert

1:57:32

between um the sort of contravarian graph indeed construction and the covariant one but

1:57:39

um let me quickly explain um what this contravarian graph and D

1:57:46

construction is all about so um

1:57:56

let's suppose that we have a function f which goes from B op to cat

1:58:04

so um some people call this a contravarent function from from uh beta cat but

1:58:12

whatever what we want to end up cooking up is a category which is called Gro of

1:58:18

f and it comes with a projection phone tool that goes into B so how do we do it well it's all

1:58:25

basically described here um the quick kind of picture to have in

1:58:31

mind uh looks something like this so

1:58:42

the quick kind of picture to have in mind looks something like this so we have this funk tour from

1:58:48

biop to cats which is called f so if we have an Rog in the base

1:58:56

category that goes from B to B Dash well when we sort of apply this function

1:59:01

f then like B Dash is going to become this uh

1:59:08

fiber category here F of B Dash B is going to get sent to this fiber category

1:59:14

F of B and then G here is going to get sent to or it's going to generate this

1:59:21

um functor which we could call F of G op and that kind of goes in the opposite

1:59:28

direction to G right because really f is a contravarian functor so like even

1:59:34

though the arrow in the base category goes from B to B Dash the arrow

1:59:40

um from the fiber the arrow between these fiber categories goes in the opposite direction it goes from the

1:59:46

fiber category over B Dash to the fiber category over B and we can call this

1:59:51

kind of functor f of G arp sometimes called G Star sometimes this

1:59:58

kind of thing is called a substitution functor so this is the kind of data that

2:00:04

we're dealing with but what we want to do is to sort of take this data and sort

2:00:10

of in a sense rub out the bubbles and stick things together so that we get a

2:00:16

kind of big category and that's going to be our contravariance uh grothend

2:00:21

deconstruction but it's a little bit tricky because we really want there to be a funk tour from what we get into

2:00:28

this category B so somehow we've got to sort of um deal with the fact that this

2:00:35

substitution functions in a sense going in the wrong direction

2:00:40

um like if you don't overthink it if you just follow the definition it's pretty

2:00:45

straightforward um so this is how this

2:00:52

um how this contravarian growth and deconstruction is defined

2:00:58

um it has objects like before which consist of uh pairs of an object of a

2:01:04

base category and an object um X in F of B

2:01:11

and then the arrows are as described here

2:01:17

so maybe easier to see this in a picture

2:01:31

so we want to think about what it means to have an arrow from B comma X

2:01:40

to B Dash comma x dash and this is going to be an arrow of our

2:01:47

um contravarian graph and deconstruction of f so such an arrow

2:01:53

of this graph and deconstruction is going to consist of a pair G and H

2:02:01

and now G is going to be an arrow in our base category here which goes from

2:02:09

um it goes from B to B Dash

2:02:14

and now h goes like this so what's going on here well

2:02:22

um we've got this object x dash in the fiber above B Dash

2:02:28

and then this kind of substitution function is going to send this to F of G

2:02:34

of x dash and then what we want to do is to have H

2:02:40

as an arrow from X to this thing so

2:02:45

um in a sense x dash is getting sort of fired back into the fiber category over B and then

2:02:54

H is allowing X to connect to the image of that x dash

2:02:59

and that's what an arrow in this um in this contravarian graph and deep

2:03:05

construction looks like and then you know the the weight composition and identities work it's

2:03:12

sort of analogous to the um the covariant case you can you can figure

2:03:17

that out for yourself but yeah so what we have here

2:03:22

so yeah what we have here really is just a sort of Jewel of what we had before

2:03:29

um so we know what vibrations are now we know about this contravariant growth and

2:03:35

deep construction and then what's going on up here um these things are just called discrete

2:03:40

vibrations so you can get these by sort of dualizing the notion of op vibrations

2:03:47

that we've already discussed and then um this is our category of pre-sheaves and

2:03:54

then this is our sort of contravariant elements category Construction and if you take a look at chapter two of

2:04:02

Emily Real's book category theory in context you can find out more about how

2:04:08

you figure out the elements category um with respect to one of these uh pre-sheves and

2:04:15

um all of this kind of stuff at the top here okay so let's take a look at a really

2:04:22

nice example of a vibration um so suppose that we have a category B

2:04:30

and it has all pullbacks so for any kind of corner

2:04:36

consisting of a pair of arrows with a common Target we can find a pullback of that kind of

2:04:42

diagram so there are lots of examples of categories like this like sets for

2:04:48

example now what we claim is that if we take the

2:04:53

arrow category of B then this Funk tool that selects the

2:04:59

co-domain is going to be a vibration so

2:05:04

you could be a bit confused at this point because I've already sort of claimed that this funk tour is an OP

2:05:11

vibration so how could it be a vibration and not vibration well it can be such

2:05:17

fun tools are sometimes called by vibrations and um yes Cod is a by vibration in this

2:05:27

case well at the moment we're just interested in what sense it is a vibration in

2:05:35

so how does this work well basically what we want to do is to

2:05:40

kind of find how we can get something like this Arrow category as a

2:05:47

groffenheit construction so what we're going to do

2:05:52

is so what we're going to do is we're going to consider a font or F

2:05:59

from B op to cats and the way that this funk tour works is

2:06:06

it's going to make slice categories so um it's going to send an object B to

2:06:13

this slice category B slice little B and the way it works on arrows is a bit

2:06:19

funny because this has to be a contravariant function so if we have an Rog from B to B Dash that corresponds to

2:06:26

an arrow G op from B Dash to B in script to B op and then what this arrow is going to

2:06:33

turn into under this functional f is this substitution functor here and

2:06:40

that's going from script to B slice B Dash descriptive B slice B

2:06:45

and the way that this works is by doing pullbacks okay so if we have

2:06:52

an object in script to be slice B Dash that's going to be an arrow in B Dash

2:06:57

so there it is and if we pull that back along G then we get this arrow pi2 and that's

2:07:05

going to be the image of e under this substitution functional G Star

2:07:11

so this is telling us how this front door works on

2:07:16

objects the way it works on arrows is kind of given you can get it by thinking

2:07:23

about the Universal Property so then the idea is basically that if we

2:07:28

take the um the contravarian graph and

2:07:33

deconstruction of this F then this is gonna give us back our

2:07:40

Arrow category so that's kind of interesting um

2:07:47

so what's going on here well this is really an example actually of a sort of

2:07:53

application of a result from this paper here or at least this is where I saw the

2:07:58

results uh framed by categories and monoidal Vibrations by Michael Shulman

2:08:03

so in result 3.9 he says that if you have a vibration

2:08:09

p uh it's going to be an OP vibration as well if and only if

2:08:15

for every arrow in this category B uh we have this substitution functional

2:08:21

G star has a left eye joints and this is indeed the case for us

2:08:27

because like um we've got like these slice categories here

2:08:33

and we've got this functor G exclamation mark that we talked about before that

2:08:38

you know just sort of takes an object in this slice category like e here

2:08:44

and replaces it with G after e so this sort of post composes with G and then we have

2:08:51

this G Star here which is the left sorry which is the right adjoint of G exclamation mark and G Star sort of

2:08:59

takes objects in this slice category and pulls them back along G to get stuff like this

2:09:09

and so since um G star has a left adjoint for every G we

2:09:16

can apply this result from Shulman um and it says that in this case

2:09:22

we're going to have the um our vibration

2:09:41

is going to be a by vibration it's going to be both for vibration and an OP vibration

2:09:47

so that's a nice result um this whole vibration is is pretty

2:09:54

interesting uh it's discussed a lot in um

2:09:59

uh Bart Jacobs book um categorical logic and type Theory where

2:10:05

I'm taking quite a lot of my material from there and in particular we can sort

2:10:10

of look at a restriction of this setup to where we're using monomorphisms so in

2:10:17

particular let's consider a new phone tour now um from be op to cats

2:10:24

and um rather than sending an object B to

2:10:32

the whole slice category let's send it to what we'll call this category of

2:10:38

predicates and what this is is it's the a full subcategory of this slice

2:10:44

category on the sub-objects of B and what do I mean by the sub-objects of B well I mean that

2:10:51

um we look at the monomorphisms into B so the objects of this thing are going to

2:10:57

be arrows into B some of them are going to be monomorphisms so we can take the full subcategory on those monomorphisms

2:11:03

actually let's cut down on the uh equivalent stuff let's just take one

2:11:10

um non-equivalent um copy of each monomorphism

2:11:16

so then we've just got like just the sub objects so it's just a way to cut down uh on

2:11:24

equivalent monomorphisms so we have this that we could call the category of predicates of B and this is what F sends

2:11:32

little B to and then again um when we have this Rog we get this

2:11:38

substitution function G star that just pulls back these sub objects along G

2:11:44

so um this is a a nice um thing and uh this

2:11:51

funk tour again we can look at the graph and deconstruction of it and we've got all this kind of vibration stuff going

2:11:57

on and um basically we have situations that look

2:12:03

like this so if we take B is set then we have this sort of category of predicates

2:12:08

this is discussed in chapter zero with Bart Jacobs book and

2:12:14

um the idea basically is that like we have these sets and these functions like

2:12:21

this function length from words to numbers now um

2:12:26

the category of predicates of n is going to

2:12:33

have objects corresponding to the sort of subsets of n for example here's a subset

2:12:41

this is corresponding to the um numbers that satisfy this property that

2:12:48

they're even and then if we have like a function like this length function from words to

2:12:55

numbers we get this corresponding sort of substitution function which sends

2:13:00

predicates on end to predicates on words and to get how this works we just look

2:13:08

at this description of this sort of predicate or subset of numbers this is the set of numbers where is even is true

2:13:15

and then we do the substitution where we substitute this number n for the length

2:13:21

of a word and now we get this kind of comprehension which is describing

2:13:27

um a predicate or a sub-object or a subset of this set of words and in this way we're able to go from

2:13:35

this sort of category of predicates over numbers which we can think of as like

2:13:40

the sort of lattice of subsets of numbers to this lattice of subset of words and we're sort of doing it by

2:13:47

substituting and this is a very rich sort of structure and in Jacobs they

2:13:53

discuss how all sorts of things in logic um can be obtained by thinking about

2:13:58

this kind of category of predicates and there's various different sort of adjoint funk tools and things that are

2:14:04

related to this

2:14:11

so one more a really beautiful example um suppose that we take

2:14:19

a category e which is both complete and co-complete

2:14:27

now what we can do is we can consider a

2:14:33

function like this I'll call it blank comma e so um

2:14:46

what this is going to be is it's going to be a fun tour from

2:14:52

cat op to cat

2:14:59

so the way that this works is if we Supply a category C then we get this

2:15:06

category of functions from C to E

2:15:14

and also if in cats we have this funk tool k from C to D

2:15:21

well then we're gonna have chaop

2:15:30

from D to C in catop and then this film tool is going to send

2:15:36

this to um this function or k star

2:15:43

which is gonna allow us to translate Funk tools from D

2:15:51

to e to from tools from CT and the way that this um this K star

2:15:59

works is it basically takes a funk tour from D to e and it sort of pre-composes

2:16:04

it with uh this funk torque here now the lovely thing about this is that

2:16:11

if you know about can extensions you know that in this case this form tour

2:16:18

here is going to have a right adjoint called rank a

2:16:24

also a left eye joint called Lan k and so

2:16:33

again we can apply um shulman's results and it's going to

2:16:39

tell us that um if we do the sort of graph and

2:16:44

deconstruction of this

2:16:52

that's going to be a vibration of course I'm just going to go into

2:16:59

cats but it's also going to be an OP vibration in fact and so actually what we have

2:17:08

here is a by vibration in fact uh I think it's actually something called a

2:17:13

try vibration now I've got to admits this is um a bit new to me and I haven't checked

2:17:19

all the details here so you've got to take this last thing I've said with a bit of

2:17:25

a pinch of salt but still I think these kind of if this kind of stuff works it's very lovely

2:17:31

because it's showing how all sorts of very immense structures are being organized in lovely Ways by these

2:17:37

vibrations so okay so I've said a bit about vibrations and as promised this

2:17:44

stuff does relate to these ideas of lenses and so in particular I'm talking

2:17:49

about the ideas of grothen leak lenses that I found out about from reading a

2:17:55

paper by David spivik I shall put a a link to it in the description but

2:18:00

um basically the um the idea is like this

2:18:06

suppose that we have a funk tour from C op

2:18:12

to cats now we can take a grothend construction

2:18:18

of that um maybe the most direct thing to do would

2:18:25

be to use the contravariance growth and deconstruction but that's not what we're going to do we're actually going to

2:18:31

think of this as a covariance fontor so that's fine we can just Define say

2:18:38

category D to equal C op and then think about this as a covariant phone call

2:18:45

from Dita cat and so we can perform the covariance growth and deconstruction on

2:18:52

F and then we're going to take the opposite of that

2:18:58

and that's what we Define as the category of lenses of f

2:19:05

and also this thing comes with a projection functional right because like the graph Andy construction of f is

2:19:13

going to come with a projection function which goes into D and so if we take the

2:19:19

opposite of that we get this functor that goes into

2:19:24

d-op or that's the same thing as C so this is what we have this is our

2:19:31

category of lenses there's so there's loads of different kinds of lenses that people study and a lot of them tend to

2:19:39

live in categories like this for some kind of a font or F from c-op to cats

2:19:45

and I want to relate this quickly to the

2:19:50

ideas um and so I want to show you quickly how we can get some perhaps familiar lenses

2:19:58

if you've seen them before from this kind of approach so so I'm just going to

2:20:04

quickly go through this um basically if you look at this

2:20:09

construction like you can spend a quite a long time sort of untangling it and seeing what this category ends up

2:20:16

looking like and you end up finding something like this that this is going to have objects as pairs of an object of

2:20:24

c and an object X of f of c and then an arrow from C comma X to C comma x dash

2:20:31

is going to consist of an arrow from C to C Dash that's going to be our get

2:20:37

and then also this Arrow H which goes this way that's going to be our put and

2:20:45

I'll just scan over these pictures that show you how to do composition

2:20:50

you can pause the video if you want more details actually I'd recommend checking out uh

2:20:56

spivik's paper it's very clearly written so how do we use this idea to get it

2:21:03

some so how do we use this idea to get to some simple source of lenses

2:21:09

well do you remember this Fung tour here that we encountered earlier this is the

2:21:15

sort of contravariant font all that makes slice category so this is this uh contravarian Contour from beta cat that

2:21:22

we saw before it sends objects of uh be up to the slice categories if we

2:21:30

have an Rog of B then um the sort of corresponding

2:21:36

substitution functor is basically going to work by pulling stuff back along G

2:21:43

incidentally the way this substitution function works on arrows I didn't mention it before but I'll mention it

2:21:49

now so if we have an roh from E to e Dash in this category then when we apply

2:21:55

this substitution functional G Star we're going to get this Arrow here which is the unique one that makes this

2:22:03

diagram commute where these things here are pullbacks so there's a theorem in

2:22:11

McLarty about this uh theorem four point something uh maybe 4.9

2:22:18

um and so yeah

2:22:25

so anyway if we take this funktor well let's use a category called C instead of

2:22:31

a category called b um and so we have this function here let's call this one called The Slice

2:22:37

Fung tour and it turns out that if we then um get this category of lenses of this

2:22:45

slice Funk tour using this construction I was just talking about so basically we're talking about

2:22:51

doing the covariant graph and D construction on slice and then taking

2:22:56

the opposite of that well it turns out that gives us this category of so-called

2:23:02

dependent lenses and the objects in this category are

2:23:07

going to consist of pairs of an object C and also an arrow X

2:23:16

which goes into C so they're going to be what the objects of this uh

2:23:23

and so they're going to be what the objects of this uh category look like

2:23:28

and then it turns out that if you restrict your attention to the objects of this uh category here that have the

2:23:36

form that they consist of a c and a projection from c times y

2:23:44

into C so that would be a projection Pi one well if you look at those kind of

2:23:49

objects and you look at the full subcategory of this uh category of

2:23:54

dependent lenses on these kind of objects then it turns out that that gives you this category of kind then it

2:24:04

turns out that what you get is this category of so-called simple lenses so

2:24:09

basically we can think of this as having objects as pairs C comma y

2:24:15

and then the idea is that amorphism from c y to C Dash Y dash is

2:24:22

and then the idea is that amorphism from c y to C Dash Y dash is going to consist

2:24:29

of a sort of get map which goes forwards and then this

2:24:34

sort of puts map which goes from c times Y dash to y so

2:24:39

um basically if you do all of that fancy graph and neat construction thing and

2:24:45

then you so basically if you do all that kind of fancy graph and deconstruction thing using that slice category and

2:24:54

pullback based um function we were talking about before and then you sort of restrict it to

2:25:01

these um particular objects you end up getting this lovely uh category of

2:25:07

simple lenses and the sort of notion of how you compose like one of these get

2:25:14

put Arrows with another get put arrow is sort of baked into that so I'm really

2:25:20

just um just sort of tiptoeing around the outskirts of a very vast subject which

2:25:28

is this subject of of lenses and so um if you want to get in and so if you want

2:25:35

to get more into this I recommend um David spivik's paper also David Jazz

2:25:41

Myers has lots of nice material on open dynamical systems that you'll see backs

2:25:48

onto these kind of ideas