Hey everybody Dr. O here in this video we're going to talk about the movement of oxygen and carbon dioxide throughout your body throughout your tissues and then into and out of your lungs as well. So what you can see here we are actually we're at the lungs we have the respiratory membrane which is going to be a single layer of simple squamous epithelium that forms the alveolus a little bit of a fused basement membrane of connective tissue then a single layer of simple squamous epithelium that is the capillary so that's the respiratory membrane so what you see here this would be we're looking at the the blood that's coming from the pulmonary artery so it's gone out to the body it's used up its oxygen it's picked up carbon dioxide and then it's being pumped back to the lungs from the heart.  Now we could talk about the partial pressures and all that but I want you to get bogged down with individual numbers 40 millimeters of mercury here there whatever just remember that diffusion is going to cause things to move from where there's a high concentration to low so carbon dioxide is driven into your lungs because there was more of it in your blood than in your airways oxygen is driven into your blood because there was more oxygen in your airways in your respiratory system than there was in your blood and then we go to the tissues and the opposite happens now the blood is being pumped you know from your left ventricle through your aorta wherever it's going to go and now this oxygen rich arterial blood is going to drop off oxygen instead of picking it up because there's more oxygen in your blood than there is in the tissues so oxygen is going to be detached from your hemoglobin making your oxy hemoglobin is now going to be called deoxy hemoglobin but the oxygen's been detached and it's going to be driven into your tissues where it can power cellular respiration also known as internal respiration and then carbon dioxide is going to be picked up by your blood because there's more carbon dioxide as this metabolic waste product in your body fluids in your interstitial fluid than is in your blood so the opposite has occurred so at your airways oxygen is driven into your your blood and carbon dioxide is driven out at your body tissues wherever we're at here oxygen is being driven out of your blood to your tissues your cells and tissues and carbon dioxide is driven in so think about that let's just kind of try to follow like a molecule of oxygen so we're at the airways oxygen is picked up by the hemoglobin on one of these red blood cells and it's going to be taken back to your heart through the left atrium left ventricle your heart pumps again blood travels through your aorta and it's going to travel through your circulatory system till it reaches your big toe or wherever it's going now we're here it's going to drop that oxygen off and while it's there it's going to pick up a co2 and we'll talk about how co2 is transported in a moment then it's going to flow back through your venous system it's going to get back to the heart reach the right ventricle where it'll be pumped into your lungs again to drop off that co2 and pick up another molecule of oxygen and do it again and again and again all right but so just you know almost all your oxygen is going to be carried on carried on hemoglobin we covered that back in the blood chapter a tiny bit can be dissolved in your plasma but let's look more specifically at the three ways that carbon dioxide is carried back so about number one about 7% of the carbon dioxide will be dissolved right in plasma and carried back to your your heart and lungs so about about you know 70% is going to be dissolved it's going to become what's called carbonic acid so as you can see here carbon dioxide and water are going to form carbonic acid that's a huge deal because that basically means that carbon dioxide is a proxy for this weak acid carbonic acid which is why your respiratory system is critically involved in the maintenance of your body's pH if you see an acid based disturbance in the body the first place you would look is the respiratory system because if you have too much carbon dioxide that means there's going to be too much acid in your blood and your pH would drop potentially dangerously low if you have too little carbon dioxide like if you're hyperventilating then you would have too little acid in your blood and your pH would climb so hopefully you can see why it's very very important we'll come back to acid based disturbances labor the last 23% of carbon dioxide is carried on carbamino hemoglobin so we thought we know what hemoglobin is oxy hemoglobin is hemoglobin carrying oxygen deoxy hemoglobin is hemoglobin that's dropped off its oxygen of body tissues but then a lot you know a decent sized chunk of carbon dioxide will actually attach to a hemoglobin forming carbamino hemoglobin and that's going to be that's how hemoglobin can help carry carbon dioxide back to your heart and lungs so when you think hemoglobin you should primarily think oxygen that's its primary job but it's like while i'm here i may as well grab some carbon dioxide and carry it back to your lungs and that's what it does all right so those are the three ways that carbon dioxide is transported through your your circulatory system okay that is the relationship between external respiration breathing in and breathing out and internal respiration that's how oxygen gets from your atmosphere to your cells where it can generate ATP and that's how carbon dioxide is carried away i hope this helps have a wonderful day be blessed


Yeah, some code and benchmarks and codes and benchmark and Hopefully that's gonna be useful for some of you So I'm a software engineers engineer for elastic in the lock stash team. So lock stash is written Jirubi entirely And I have two colleagues here guy and perry We're working with me My team So yeah, we're gonna we're gonna talk about Fast IO or how to achieve efficient Persistence using a Jirubi and Java So this is this is work. I've been I've been doing to For the for the actual implementation of a persisting queue I'm gonna and I'm gonna show you that a little bit later on So if this is this is too boring for you guys you can jump to the code right now There's a Jirubi conf 2015 repo with with all the slides and the code and the other two repose and map and MAP cues are the actual Mapping implementation and the cues implementation Okay, so first of all we're gonna talk about Using data or manipulating data in Ruby Yeah Yeah, so Soon enough you're gonna be asking yourself why there's no byte array in Ruby or you know, I wish there was a byte array In Ruby so in Ruby when you manipulate data everything is is true using you know using strings actually to hold the data and There's two important things that you have to consider when I when doing that when the you know Manipulating data is the character set and encoding with your strings and if you're calling out to Java Java classes then you have to Pay attention to the actual type conversion that occurs between Ruby a Jirubi and Java Now there's a very nice Wiki for that that explains some of the pitfalls and some of the the techniques that you can use to Get more speed when we're doing that So why I urge you to actually look at that if you ever want to play with you know crossing the world between Ruby and Java Okay, so first of all, let's talk about encoding I'm not gonna go through all the details for encoding. I'm gonna talk about a little bit the Ruby side and the Java side So these are some of the stuff that that you may have seen for encoding of course the the first line The encoding for the Ruby files So the the strings that you're gonna define in your Ruby files are gonna be encoded in that character set So UTF-8 in that example There's classes and constants that you can use a UTF-8 ASCII 8-bit and This is important to understand what ASCII 8-bit is and we're gonna see the equivalent in the in Java Which is ISO 88 59 underscore 1 This is actually a transparent 8-bit character set. So it's equivalent to saying no no encoding, right? and So main most of the these encoding Methods are in the string class. So you have like force encoding encode Encoding which which is gonna give you what the encoding that the string is in right now Is it a valid encoding and and the actual byte size of a string? So it's inter it's it's important to note here that The only thing that does transcoding in here is the encode method So force encoding doesn't do any transcoding. So it's only a tag for the string to tell it in what encoding it is So I'm gonna show you some code that uses that So the equivalent in the in Java So we have like the default character set in Java And then there's some some classes and constants again for for the encoding So you have utf 8 and then like I said ISO 88 59 1 which is the 8-bit transparent encoding You can set the default encoding in your Java application using the the file that encoding You can get it With as a property or you know if you're you're from Jirubi you can use the end Java file dot encoding to see what the default encoding is in Java Okay, so let let's show an example here if I define a string with Ericss Antigu or a cute accent e Obviously, this is a unique code UTF-8 is going to be a two-byte Encoding so we see that the encoding here is utf-8 if we ask the size. It's it's a one character String if you we check the byte size, then it's two bytes If we force the encoding to ask you a bit which is going to be a transparent 8-bit encoding We get back that that string and if we ask for the size it's going to be two and bite sizes too So this is to show the difference between you know a string length and a bite size for that string that same string Okay, now let's talk about object persistence so And this is why I'm obsessing with string and it's very important when we talk about Persistence and IO it's important to to you know get the the the big picture about encoding and make sure that that you actually Understand that because you may end up having you know wrong encoding and problems with that So The problem is that all Ruby IO use a string so you you don't have a choice you have to go through strings one of the problem that we have is that if you are a Jruby object if you want to do persistence Cannot be serial it cannot implement the serializable serializable interface in Java So you cannot benefit native native a serialization or really faster realization using I don't know Frameworks like cry or stuff like that. You actually serialize your object within Java This is because Jruby objects actually hold references to the runtime and and we cannot serialize that I know that there's been some work To actually be able to have serializable objects in Jruby There's some open issues about that, but it's not there today So basically to persist an object you need to serialize it somehow To a string because you want to write it, right? so You can use you could use Marshall dump, but that's the same thing. It's gonna serialize to a string also Jason and so on so so you're stuck with strings So so yeah, we're gonna we're gonna play with strings and We're gonna do some benchmarks with different strategies all the code and example are gonna use string object. So I'm not gonna talk about serialization. This is gonna be your problem to choose whatever method that you want to serialize You can talk to guy the other of junior Jackson here or maybe a Satoshi for a message pack go see these guys But here for the sake of these these examples We're just gonna deal with with strings objects string buffers and then persist that But of course in the real world You're probably gonna have some serialization cost to include into these these benchmarks are Okay, so what's the motivation here? this is so I work on log stash and This is basically log stash the log stash pipeline. It's just three horizontal cylinders and two vertical cylinders Connected with our roads. Basically, that's it. That's a few years of software engineering right there So we use so these these are the stages the input filter and output stages in in lock stash and they are Connected through a size queues and basically we use size queues there to actually Propagate back pressure when the outputs are slowing down So these size queues gonna fill up then then the the filters won't be able to Push an event in there. So the the other size queues gonna fill up and so on and then it's gonna propagate the back pressure back to the input the input plugins or the input stage So the idea here is that these size queues are in memory queues So if there's a crash a system crash and application crash or whatever We're gonna you're gonna use all these in flight events and in lock stash These are smallish queues, but nonetheless this can cause a problem, right? So one of the One of the way to to solve that is to see can we can we persist those events in these queues? So there's many solutions to that problem, but one of which is saying, okay, we're gonna do Just a persistent queue implementation in right there and and that can be just a drop-in replacement to the In memory queue and then be done with it It's going to be persist and if it crashes then when the application restarts I'm going to read the persisted queue and then and then continue on with the events so that leads us to trying to Find out the best way to persist because lock stash processes, you know Thousand hundreds of thousands of evin per second. So we need to be really really fast in terms of persistence so RIO performance or you know storing as many objects in the last time Possible and oh This is not Satoshi here in the picture Okay, so different strategies that we're going to explore We're gonna the base the base Benchmark that we're going to use is you know plain ruby falayo Obviously after that we're going to see Can we do better with m mapping so memory mapping? I'm going to talk about that We're going to have a java class implementation And we're going to test different strategies to talk to the java class. So implicit casting explicit ruby side java side casting play with the character set a little bit We're going to build a j ruby extension in java And then have a pure ruby implementation also and and check the the performance results Okay, all benchmarks Basically, these benchmarks are for right speed only If we have time I'll come we'll we'll see the actual queuing implementation Which you know reads and writes but these basic benchmarks are for right speed We're going to use a one four and sixteen k buffer buffer size again. These are plain string buffers And we're going to be writing End times two gigabit two gigabyte files So the end times depends on the on the test. So I was just I just wanted to make sure that it takes long enough to get you know results That are in the few second range So this is this has been run on my MacBook Here it has a Local SSD. So of course, there's a lot more IOPS than than a spinning disk Latest java and latest j ruby 17 I haven't run the test on 9k yet, but I'll do that Okay, so standard ruby file IO So if you want to go in the repo and check the the implementation I have a method there that's called bench And it passes me a buffer in a right count and and the only thing that I do So this this bench Method is actually benchmarked. What's happening in in that block? And I'm not counting the creation of the file So it's just going to go on and Write the the buffer that's giving to me. So it's going to be you know one k four k 16 k and so on So So this is the first result that we get this is going to be our our base result So we see that we have you know between You know 680 and about 900 megabyte per seconds in terms of throughput With with file IO with standard file IO Okay, so now an alternative is to use memory mapping so Conventional file IO use read and write system calls and that involves you know copy operation between the file system pages Incarnal space and the memory area in user space. So there's always copy going on But memory mapping IO Uses like virtual memory mapping from the user space directly to the file system pages and with a memory map file The entire file is going to be accessed using a byte buffer class And a byte buffer is that is you know, that's it. It's a byte buffer So you you actually manipulate your file the underlying file just as a byte array And you put bytes and get bytes so you don't have anything Like like read lines or enough files or anything like that. It's just a big byte array that you manipulate Okay, so one some of the advantages of using memory mapping So you you see the file as plain memory like I said as a byte buffer There's no need to issue read or writes If you access or you get bytes from that memory space, there's going to be page faults In the os that will bring the the the the file data from this to these these these memory areas So if you put bytes or you modify the memory map space These pages are going to be marked as dirty and are going to be flushed to this eventually So the os is going to be performing the caching and managing memory According to system loads and available memory One of the important things that the data is always page aligned. So there's never Buffer copying that's required. So this is this is probably one of the biggest benefit And also very very large file. I think it's up to four gigabyte can be mapped Without consuming actual large amount of memory, right because the data is pulled in as as as needed Okay, a few notes If the user process crash The the memory map file is actually intact So because those bytes have been managed by the os In the pull the plug situation Well, just like a normal file, you don't know exactly unless you've been doing You know a flush or f sync, right the equivalent of that In in with with m mapping is to use a force So force is the equivalent of flushing and then doing an f sync And these tests we're not doing that So and this is this is a strategy. So just like the file i o f I've not done any flushing or f sync in the file i o test I'm I'm not doing any any force or flushing with memory map And the performance of memory mapping is going to be relative to your file system type the the free memory that you have in your in your system For doing the file system cache and the read write block size Normally M mapping should be much faster than streaming i o This is what's to be expected Okay, so first We're going to look at a simple java implementation for memory mapping now. I don't know if I can pull that in here so this is Very simple implementation. So in the constructor here. We see that we create the file We we we get a channel And then we call map which establish the memory mapping The m mapping to that channel and then The methods here are are really Just a wrapper against the the byte buffer put and get So it's very simple implementation Okay, so we get we have different put here that we're going to use for the different benchmarks. We're going to look at that Okay, here we go. Okay. So the first one So using the java class, we're going to use implicit casting with the default character set that means that we're going to pass in Our ruby string To a java method that accepts a java string, right? So we can see it We we use out that put bytes buffer buffer is a ruby string And below this is the actual method java method which accepts a string A java string so and it it gets the bytes. So so data that get bytes And and we use the buffer Which is the memory map buffer that that's been defined And we do a put for those bytes as simple as that Okay, so in this case Using a mapping we're actually slower than falayo And and by a good margin.  Okay, so why is it slower? It's supposed to be much faster. What's happening? Um, so the first question was okay. Is there is there encoding transcoding going on? Um, so let's see if we can you know specify explicit encoding here Um, since our string here are defines that simple, you know a b c d f And then we do a force encoding On as ASCII 8 bits. So our string are already, you know 8 bit transparent and And but we see that the default character set in java is utf 8. So okay, maybe there's transcoding going on So instead of using the get bytes the default get bytes Which is going to be using the default encoding in java utf 8 Let's use the get byte and specify our character set, which is going to be iso 88 um 88 59 1 right So this is what we're going to do here instead of doing a put byte buffer We're going to put byte with the character set and this is going to be passed onto java And there's going to be explicit character set here to avoid any transcoding And this is what we get. So it's a little bit faster So this is not the transcoding problem. So what's happening? So of course here we can look at, you know type conversion. Is this is this what's happening? Um, we see that, you know, we use a buffer a ruby buffer and we pass it To a java method that uses that accepts a string a java string So let's try and do explicit ruby side casting Instead of, you know relying on the j ruby Implicit type conversion So you can see on the upper part where we do the the out the put bytes We're going to do buffer to java bytes So this is going to pass in a byte array a java byte array to that method And this is going to be using below the java implementation of put bytes which accepts a byte array Okay, so instead of so we do an explicit ruby side type conversion So what kind of performance do we get? Um, it's a little bit faster, especially with the bigger blocks So at the 1k block, it's somewhat similar And then 4k and 16k it's getting it's improving Um So this is getting interesting right, uh, we can see Uh, a very big increase in the 16k blocks Um, and um, we're going to see if we can improve on that So We're going to do we're going to try Some explicit java side casting so instead of doing a two java bytes So we're going to you know use a new method that's called put ruby string with the buffer with the ruby ruby string buffer And use and create a method that accepts a ruby string object Um, and then on that ruby string which is data we're going to do a get byte list So get byte list on the the ruby string class actually gets us a byte list Class from which we can get the bytes. So there's two ways to getting the bytes you can get Safe bytes by doing a copy or you can use unsafe bytes, which is going to give you a pointer to you know To the actual underlying byte buffer For that string. So this is what we're going to do here so Okay, so this is getting really interesting We can see that we get up to five gig per second With the one k block and and and you know seven gig eight gig per second for the the four k and sixteen k This is very very good So so we see that the you know The cost of the implicit conversion in j ruby when crossing the world between j ruby and java is very very expensive And and there's basically two ways to avoid that from the ruby side Or from the java side. So when you do it from the java side, of course You have to know a little bit more about the the j ruby api in terms of you know And and especially ruby string. I don't know if any of you have checked the ruby string class implementation It's probably one of the biggest class Yeah, it's it's just amazing So I won't go into the details, but uh, okay, so now Another implementation. So instead of doing, you know, uh talking with a plain java implementation Let's try to create a j ruby extension extension in java and And so our benchmark is pretty much the same. So we're going to use, you know, put bytes and buffer our ruby string and then below we can see the the A j ruby method defined as in java So there's there's some boiler boilerplate code in there. It's basically to check the arguments But at the arrow we can see that we do a buffer put With the actual so we know that the ruby object there is a ruby string So we can do it approximately the same thing is Use the byte list and use unsafe bytes To avoid the copying of the bytes and And that's it. So Performance for that is somewhat similar to To our explicit java that we had but for, you know, a little bit faster for the 1k block So we shave a little bit more time here And if we compare that to instead of using unsafe bytes, so for me when you do persistence Uh, I think it's it's pretty safe to use unsafe bytes because this is usually the end of the story for the string Right, you're not going to mutate the string after that. You're just saving it and you're persisting it But if for whatever reason you you actually want to copy those bytes to get a safe string to persistence Then you can do that instead of using unsafe bytes. You can use get bytes which does a copy And the difference in performance is this so we see that it's pretty significant in terms of performance cost Okay, so the last implementation is a Um Is simply j ruby calling into java directly, so it's a it's a pure ruby implementation of that M mapping class that we've created You know in java or as a j ruby extension and Basically, so the same put buffer buffer put bytes buffer and then below we can see the implementation So so there's the you know the construction So in ruby we're calling the the the the actual java class to create the the m mapping and then eventually we have to put bytes with data and then We we do the same, you know data data to java bytes and so on so performance that we get with that is You know pretty similar to the to the explicit ruby performance. So not that good okay, so um Like I said the uh the motivation for that was to actually implement a persisting queue or persisting size queue. So Uh, i'm gonna take a few minutes. So I don't know how we we are with time Yeah, okay, so i'm gonna go through those slides so This is a schema of the persistent queues Implementation so there's two implementation. There's the you know a standard queue Just the same same api as the tread queue and then there's a size queue Which are you know blocking and tread safe implementation? so they rely on The page endlers and the page queue implementation So page queue is simply a non blocking non tread safe base queuing implementation that uses the page endler To do the m mapping creating the pages and and storing the metadata and and so on So those page ender can have different strategies and there's two strategies So there's one which called the the page cache which caches the the the last uh use pages Because typically you have two active pages when you're doing queuing So there's going to be the tail page and the head page The head page is where you push And and these are Append only pages that are created So and then there's the tail one where you actually put the items right And there's the single page strategy Which is useful because in the size queue implementation Typically the number of of items You know in the queue is small So you can actually use the same page memory map and then just do a ring buffer in in it So that avoids creating more and more pages which is costly using a mapping So this is what I just said So typically when when persisting data, it's just append only pages and these pages You can define, you know the size that you want I'm doing, you know, and we're going to see some more benchmarks, but I'm using two gigabyte pages And there's metadata, which is an imab file itself that that keeps pointer to what is the tail, you know the tail Page index and the tail page offset So where do we read in that page and the same for the head for doing the push on the queue? So just a word of caution If you play with that, you know, this is work in progress and you know proof of concept code. So obviously You should be careful Again, there's no serialization involved These tests with the queuing have been done with one k string objects only The the the map page size is two gigabyte We use a two item page cache and and The for the test we push two million items per producer. So sometimes we have multiple producers. So that's going to be two million per producer Okay, first the persistent size queue It's a limit limited queue size For this implementation, we use a dual queue implementation We push to both the persistent queue and the in-memory queue the in-memory queue is actually just an array Um, so we serialize to push the persistence Persistent queue and we push the original object in memory queue and then when we pop We actually need to only pop from the in-memory. So it avoids deserialization cost And we just update the metadata on the persistent queue So the persistent queue is only there if there's a crash and you need to reread The the the queuing to actually uh, not lose data in that case Okay, so what do we get um with page cache We get so we have one consumer one producer one consumer to producer two consumer one producer and two consumer to producer treads To try different strategies. So we pop and push in those queues. So we get Uh, approximately 100, you know ish megabyte per second in terms of throughput with a size queue Or you know 100,000 Uh, 100, you know between 100,000 and 150,000 uh transaction per seconds So with a single page we get a little bit faster Especially in the the one consumer one producer Okay For the the persistent queue implementation. So this is not the size queue. This is a standard queue that's going to grow indefinitely If if they're the consumer are not catching up Uh, and the push and the pop operation are done are persistent We need to serialize on push and we need to serialize on pop And this is essentially just a thin thread safety wrapper around the page queue implementation Okay, so for read and write we can see that we get a little bit faster Okay, I'm almost done And so for read and write operations So we have consumer and and producer at the same time If we do a write then read then we get a little bit more performance and if we do only write Then we can get up to 500 megabyte per second on only writes So just a few notes Do we really need you know dual queue implementation for the size queues it really faster? I don't know I need to test that The the caching strategy is it optimal? Can we find better page size and cache size? How does that perform on spinning this that would be interesting? I I haven't tested it Is there a faster alternative to the the current page and metadata algorithm that i'm using I don't know You got to try that And the code has to be reviewed in terms of resiliency, you know doing the force do we need to force? Maybe at specific points Um and the last thing you know the elephant in the room, of course, it's the serialization There's a huge cost associated with that so Again, you can talk to guy or uh to set her sheet about that And thank you that's about it


I'm really very much enjoying this conference because it brings together very different physics fields using very similar tools. So whenever there's progress in one field, we may be able to transfer it to a different field and so the talk I'm giving is inspired by particle physics, the Higgs sector of the standard model or related physics, but perhaps the ideas we had about this may be transferable to other different fields. I'd like to invite you to replace these words asymptotically free to any other property you would like to solve, any other problem you would like to solve in your specific system. So this is work done in collaboration, a very enjoyable collaboration with Luca Zambelli. There's a short paper out and there will be a longer one very soon, hopefully, and it goes actually back. The idea is to work also together with Michael Scherer, Stefan Rechenberger, Michael and Luca here and we'll give talks, but on different, very different, very nice subjects. So the inspiration came from the observation that whenever there's a problem in physics, you just put a scalar and you come up with a new model and usually it works very nicely. And this is a strategy that works in very many different cases, of course, most prominently in the case of getting gauge bosons massive, in general symmetry breaking, if you want to come from a gut-like, grand-unifat, like theory down to the standard model. In particle physics you have the CP problem where you also put a scalar like the axion and there are many other examples where you put scalars and in condensed metaphysics, of course, you can also play the same trick in many instances. And yeah, the showcase is certainly the standard model Higgs sector where the metaparticles and the interaction particles are kind of bound together by the Higgs and it has been discovered and that has been a major breakthrough for this, for this paradigm just for the scalar. But it comes with a price tag. There's a price to be paid. In particular the standard model. There's this problem called naturalness. Technically it appears in terms of quadratic divergencies of the Higgs mass and it's simply difficult to get the Planck scale separated from the low energy scales, Fermi scale, or QCT scale, if you put a scalar. But as LHC seems to tell us right now, nature is not natural, so we have to live with this problem. Probably so I won't say anything about it. I don't have anything to say about it. I can't solve it today. Also when you put a scalar, you typically have to put further couplings and if you put further couplings, that means you put further parameters.  So going to very high energies and showing that the system can really be fundamental can be difficult or even impossible. So that's the topic I'd like to deal with today because if a system with gauge degrees of freedom and a scalar is asymptotically free, it can be fundamental as Francesco told us right now. So there's a currency that is accepted in the particle physics community to pay these prices, for instance super symmetry, technical or extra dimensions and then many many different proposals that in particular address the naturalness problem and some of them also address the UV completion problem. And of course also in our community we have ideas to offer for instance if you add gravity then some of these problems may go away or as just Francesco told us if you do it in a clever way with gauge-shakes your cover systems then you can have asymptotic safety and that leads to UV completion. So I'm after actually asymptotic freedom. I won't put any fermions even though I could but I just stay with the gauge sector and the scalar sector. So let me tell you what this triviality means in very simple terms, a perturbation theory. So this is the one loop equation that relates the bare coupling, 5-4 type coupling with the renormalized coupling and there's a log relation and if you fix the physics so if you fix the renormalized coupling at low energies and look up the bare coupling at higher energies then you observe this Landau-Poll singularity which inhibits that you can consider this theory as truly fundamental. Or you can reverse the logic you can insist on sending the UV cut off to infinity and this you can only do if the renormalized coupling goes to zero and then you end up with a non-interacting theory which is not what you want to have. And so for the pure scalar system, pure 5-4 theory, there's no mathematical proof but there is a strong, very strong lattice evidence accumulated over quite a number of years. So I think it's a safe statement to say that the 5-4 theory is trivial or not asymptotically free. Now if you think of the standard model there is a scalar sector, the 5-4 sector of the Higgs coupled to the SU2 left sector in a gauge version and of course also involving fermions but I just pick out the gauge interactions, say an SUN gauge theory coupled to a scalar field. So it has the mass parameter, it has a self-coupling of the scalar field lambda term lambda 5-4 and it has the coupling of the gauge field to the scalars in here. So we have three parameters and a two naive argument would be but sometimes here it that well of course the gauge theory is asymptotically free that means the gauge sector kind of switches off in the ultraviolet and then you're left with the firm, sorry with just the scalars and the scalar sector is trivial. So a naive argument is that whenever you write down such a theory it's likely to be trivial or not completable in the ultraviolet but this type of argument is actually too naive and this was already known in the very early days of asymptotic safety if you write down the beta functions. So this is the running of the gauge coupling, usual term on the right hand side, the Nobel Prize winning beta function of of course Wilczek Pulitzer with the famous minus sign and then you have a beta function for the scalar self-interaction, it shows a lambda squared term, lambda g squared g4 and it has these constants here which during my talk will only be numbers. So for SU2 these are pure numbers and this coupled system of differential equation can be solved exactly, again it was done in the 70s and this is the solution. You don't have to look at the detail, the only point I would like to make is there is a combination of these constants here which is called delta and the sign of this delta is decisive because in fact if this delta is positive, as I said a combination of all these beta function coefficients if this delta is positive then the solution tells you that the phi4 coupling is proportional to the gauge coupling. So kind of the scalar sector is locked to the gauge sector which means if the gauge sector goes to zero to asymptotic freedom towards the ultraviolet then also the scalar sector is asymptotically free and this is what you would like to have. Now the bad news is that for all SU engage theories this delta is negative. So in fact all SU and non-abili engage systems are not asymptotically free according to this line of reasoning and this you see if you just plot this coupling as a function of the gauge coupling and the gauge coupling goes to zero at some point you hit the lambda pole in the phi4 coupling. And in fact there are fewer lattice studies on this and they are kind of compatible with this picture even though some of them also point to the possible existence of a second order phase transition. And there are actually current studies going on to understand this system a bit better on the lattice. Okay so still my title was asymptotically free non-abili engage theory. So what do I have to talk about if the delta is always negative? Okay so let's assume that delta was positive. How can I do this? This was also known to the ancestors. You can add fermions and you can adjust the gauge group in such a way that this delta becomes positive. So then you have as I said the good news asymptotic freedom the gauge sector and the Higgs sector are locked and the really nice thing about it is that since there is this locking and these are related by a computable relation that means that the Higgs mass related to the phi4 coupling is proportional to the W mass related to the gauge coupling. So if you have this locking if you have such a system then you compared to the standard model lose one parameter. You can predict one parameter. That's very nice and that program has been tried to work out in more detail but the bad news is that typically if you start model building the residual symmetry after symmetry breaking from the Higgs phase it's too big to be to form a realistic model for the standard model. Another problem is that there's no really ordering principle. So there are many possibilities to write down these models by adding many fermions adjusting the gauge group and so on. So this is not what I have in mind today but let me just show you the properties of such models where this delta for some reason or another is positive. So let me show these properties. I emphasize what I show now is not the standard picture for perturbation theory in non-Abelian Higgs systems without fermions. It's a more complicated system which you need to have the delta positive but if the delta is positive then you get pictures like this. Here's the gauge coupling. Here's the phi4 coupling. Here's the Gaussian fixed point and if you start for instance with positive phi4 coupling positive gauge coupling you are attracted by the Gaussian fixed point towards higher energies and that's the manifestation of asymptotic freedom. And there are specific trajectories which attract or repel all the other trajectories so the green one here is attractive and you can really run into the Gaussian fixed point in this nice way towards the ultraviolet. So I will show stream plots where the arrows point towards the ultraviolet because I'm interested whether I hit the Gaussian fixed point or asymptotically free fixed point or not. Okay now I can rephrase the same statement the following way. So lambda the phi4 coupling is locked to the gauge coupling so I can form the ratio and that should go to a constant if the theory is asymptotically free. And the nice thing is if you write down the beta function for this psi here this ratio the gauge rescaled coupling then there's a factor of g squared and the polynomial in psi. It turns out that the green line I showed you before this one is the green line here and this is kind of the fixed point of this beta function but it's already a fixed point at finite values of the gauge coupling. So you can fix the gauge coupling to a small value and still you observe already a fixed point in this gauge rescaled coupling where this term here vanishes and that's exactly the green line. Or you can also think of it as well the Gaussian fixed point is of course a point but by this gauge rescaling I just kind of re-parameterize the point and it turns it's converted into a line. So each point on this line here is actually corresponds to the Gaussian fixed point. So hitting at some finite value still hits the Gaussian fixed point. I'd like to call these quasi-fixed points because they are already visible at finite values of the gauge coupling as zeros of certain beta functions. Okay, so things to ponder. Is there a general meaning to these quasi-fixed points meaning that I've set the gauge coupling to a finite value and I still observe beta functions which have zeros, interesting zeros. You can also view this rescaling in a different way. You can rewrite the lambda-44 coupling in terms of this rescaled coupling times a rescaled field and if the gauge coupling goes to zero asymptotic freedom then you can expect large fluctuations of the field. They are not penalized by a large action in this language and that of course happens for the 5.4 operator but if there are large fluctuations you may wonder what happens to higher order operators. Perhaps 5.6, 5.8 also become important. Okay, so the next five minutes or so of my talk I'd like to present to you an argument which is kind of on slippery ground. So if you presented this argument to me I would never believe you so you should do the same to me. But the nice thing is that in the present case it kind of works. Not completely, but it kind of works but it gives you a nice feel for what is going on here. So as I said I'd like to study higher dimensional operators so I put in addition to 5.4, 5.6 term and of course it's dimensionful so I have to put another scale. It's in the spirit of let's say effective field theory or a perturbative type of spirit. And of course you have to balance the additional dimensions by some scale. This you would do in effective field theory. Of course I'd like to go towards the functional RG so replace that scale by a sliding scale in the sense of the functional RG equations. And then of course the UV behavior should be visible for that scale going to infinity. And of course I don't want to stop at 5.6 but I can include 5.8 and so on. So I can include the full potential and infinitely many couplings here. And I may expand about zero field or I may expand about a non-benishing bath. It's kind of equivalent but one or the other formulation might be more convenient. Usually perturbation theory is done with this type of expansion because there are theorems that say well if you're interested in the ultraviolet then it suffices to look at the deep ultra, deep Euclidean region where you have asymptotic symmetry. But it's actually you can kind of, hold to this argument and it shouldn't take that too seriously as I will show you. Okay and then you can just derive by perturbative means in an effective field theory language you can derive the beta function of all these couplings here. They will depend on the gauge coupling and on many many couplings. So in the end you get an infinite tau of RG equations which are all coupled to each other.  But now the point is even if you delete these higher order couplings even if you only keep the gauge coupling and the 5-4 coupling this beta function lambda 3 for lambda 3 is not zero. It still gets contributions from diagrams. So setting lambda 3 to zero is as good or as bad an approximation as setting it to any other value. You can set it to a constant you can set it to a function of the coupling whatever you want in that truncation in that approximation it's you can't tell as long as you don't include the full beta function. So let me take an agnostic viewpoint I just keep this higher order coupling in this 5-4 equation and it gives me an extra term and you can compute the coefficient and the point is now that you get back asymptotic freedom even without fermions so you get a positive delta now it's a delta prime if this lambda 3 this higher order term has a specific scaling with the gauge coupling and it involves a constant which are called zeta here. So if for some reason this higher order coupling would scale like this with a constant then I would be well off because I would find a family of asymptotically free trajectories in the system and it's one parameter family because here's this unfixed constant of course that's now a kind of a game which I can play but of course I would have to show that this really happens in the full system but let me just show you if you plot the flow towards the ultraviolet in the G-squared lambda 2 plane you again get these plots where trajectories are attracted by the Gaussian fixed point and again you can choose this gauge-free-scaled version and you have this new quasi-fixed point involving the new constant here the parameter which you can just put and in fact again the Gaussian fixed point has been smeared and you can find trajectories which hit the asymptotically free Gaussian fixed point now I don't have to stop at this low order I can go to any higher order and play the same game and I find the same picture as long as the highest order I don't include so if I go to order lambda n I don't include lambda n plus 1 if this higher order coupling skates like some power of the gauge coupling family of asymptotically free solutions and they are parametrized by one free-paramed okay? as I said this is slippery ground because you can easily fool yourself with arguments of this type and what you really have to check is the following so once you have the full series of all these once you have solved the full tower you can reconstruct the full potential and of course this potential has to be kind of physically meaningful so for instance it shouldn't have singularities it shouldn't be unbounded and so on so there are possibility checks which you first have to show but if this all works out then there is still this one parameter psi which remains and this of course has to be translated into a physically meaningful boundary condition for this potential and there are actually many further checks you have to do and it was I think Tim Morris who very carefully worked out all the arguments that typically rule out physically non-meaningful physically nonsensible potentials for instance you have to show that the perturbations about the fixed point potential are self-similar that there is a uniform convergence towards the fixed point and recently also the gravity context there has been this notion of singularity count which I will show you later so there are a lot of checks which you have to and this potential has to pass in order to be physically meaningful okay so now there is actually not only one parameter there is yet another one to make things more complicated or more interesting I motivated this rescaling of the couplings by rescaling of the fields and I rescaled it with a square root of g of course you can take any other power power p and do the same story as we did before and you end up with trajectories which are hitting the Gaussian fixed point which are asymptotically free for any value of p and they hit this Gaussian fixed point in a specific way depending on p so it turns out there are actually two parameters zeta and p that parameterize the boundary conditions for your effective potential or for your correlation functions in general okay so now I have to convince you that also in a bigger more comprehensible more meaningful framework and for this of course I use the functional rg I use the cost of the equation and of course from a mathematical viewpoint it's a functional differential equation and if you boil it down to a couple of sets of partial differential equations it's an initial value problem in the rg time or if you are interested in the fixed point equations then it typically boils down to second order ordinary differential equations couple of systems that require two initial boundary conditions to be solved so you expect already that the boundary conditions will be important for your class of solutions so I don't bore you with the details but what we specifically look at is the full potential for the scalar field and there is an equation for it we include enormous dimensions and we include the gauge the running of the gauge coupling purely perturbatively because we're interested in asymptotic freedoms so the perturbation theory should be fine at weak coupling so it's a second order pde you don't have to look at the details but what I want to like what I want to show you is that you can do this gauge rescaling with this general power p for the field and introduce a new field variable I call x and it's now a field variable that are of the potential which I call f now so f will be my scalar potential and x will be my field variable and it contains in an intricate manner gauge couplings so you see p pops up everywhere and so on it's a second order differential equation p is not fixed you choose a p and it should be bigger than zero but otherwise it's fine then you can solve this equation for p equals one in a weak coupling expansion so I'm at weak coupling I'm close to the Gaussian fix point and for p equals one here's the solution and in fact it involves one free constant theta and it involves this I like to call it Coleman Weinberg type potential so it's a typical phi for log phi term which pops up here and it's very generic it comes from the gauge loop the thing I'd like to emphasize is it contains a logarithmic singularity at the origin not so higher derivative I mean it's smooth and the first derivative is smooth but higher derivatives may contain divergencies at the origin but this is expected from the gauge loop but it's one parameter family depending on this coupling theta and also for the other powers of p there are solutions which you can work out in the weak coupling limit but this one looks particularly nice so let me show you how it looks like so again I switch on the gauge couplings to a specific value this green one here and then solve the quasi fix point equation and I get this Coleman Weinberg type solution and it looks like this here the green line it has a non trivial minimum and it goes like phi four log phi to infinity now if you go to smaller gauge couplings now you kind of switch on the RG flow towards the outer violet when the gauge coupling decreases and for smaller gauge couplings you again solve the quasi fix point condition and you get these other plots here and what you see is that the whole potential becomes flat so that's exactly what you expect from asymptotic safety that the interactions go away but yet another thing happens larger gauge coupling you have the minimum here and for smaller and smaller gauge coupling the minimum runs to infinity more quantitatively towards the outer violet G goes to zero the minimum runs to infinity in such a way that the W boson mass divided by the scale approaches the constant so that's a way how you can sidestep these typical arguments of deep euclidean region so there is in this system there is no asymptotic symmetry as always a kind of a vacuum or an expectation value of the field so let's try to understand so that's a scaling solution that runs towards the Gaussian fix point in a very non trivial manner and is asymptotically free so let's understand when you perturb the system what type of classification of relevant operators do we have it turns out it's very simple it's almost like a perturbation theory you have the relevant mass parameter on the higher order terms are typically irrelevant and you have a marginally relevant parameter in perturbation theory you would associate it only to the gauge coupling in the present system the marginally relevant perturbation is a combination of switching on the gauge coupling and switching on the potential in a non trivial way everywhere for every field but in a controlled and smooth manner so here for instance is the difference from the fix point solution I showed you before plotted for higher values of G of this marginally relevant perturbation and you see for larger gauge coupling it has this deviation for small and smaller gauge couplings it approaches very smoothly polynomially bounded the causal fix point potential I just showed you so this test is passed it really works now I'd like to give you a very important argument that tells you where the additional parameters and the additional solutions that you don't see in perturbation theory really come from so if you're familiar with say the easing model or n-type models RG flows, Wilson-Fischer type fix points what you typically do is to really fix the fix point potential is you do a singularity count or you should do it you can rewrite the flow equation which is a second order differential equation you can rewrite it in normal form so you put the second derivative on the left-hand side and all the other lower derivatives on the right-hand side and the typical structure that you find is 1 over the field squared and a numerator and a denominator so that tells you that in principle in order to find your solution you have to fix two boundary conditions or initial conditions but you have to be careful you have to avoid this fixed singularity at the origin and for this this numerator function has to have special properties so that fixes one of these boundary conditions and then you have a movable singularity when this denominator data here becomes zero and for this also you have to impose another condition and that kind of kills the two free parameters that you have in principle and you end up with zero parameters which means that those solutions are quantized so the Wilson-Fischer fixed point is really unique in three dimensions and this also leads to the quantization of multi-critical fixed points in dimensions lower than three so you end up with a zero parameter family the Wilson-Fischer fixed point is just a typical example now how does this work for our case first of all it looks very similar again for my potential function differential equation sorry ordinary differential equation I have the same type of fixed singularity at the origin and I have the same type of movable singularity so in principle you would say again you should end up with quantized solutions only one there shouldn't be any free parameter so where does it come from but actually if you remember in this Corsa fixed point solution I showed you there was this log type singularity and that means the origin actually shouldn't be as regular as it is in a scalar theory but the gauge loop induces log type singularities so it removes this first constraint here and you can permit for a larger class of solutions so the solution space is different from the one you know from scalar O and models for instance so you have to include these log type singularities so that means these are not I mean bad singularities the potential itself and derivatives stay regular at the origin but high derivatives can and should develop log like singularities and that effectively removes one constraint so that you end up with actually one parameter family of solutions and that's what we also see in full numerical solutions of this equation okay that's kind of the end of the story so I spoke too fast so I can speak very slowly now yeah so once you have convinced yourself or we have convinced at least ourselves that there are these asymptotically free trajectories in non-ambient Higgs models you want to use them for predicting something for the let's say standard model, you want to use them for the Higgs sector in the standard model and predict the infrared and of course that's in principle straightforward but since we are dealing with the full potential which you have to follow it's kind of technically complicated this last slide is under maintenance and the only result I'd like to present is so what is of interest is for instance the ratio of the Higgs mass by the W mass this you can compute and you can check which of these parameters which we have depends on or influences this ratio it just turns out that this ratio is linear and this zeta parameter and there's also p dependent coefficient so I forgot to tell you sorry I should tell you the p parameter still is in the game because it kind of defines which type of log singularity you have so for a different p you have a different type of singularity so you change your function space slightly with choosing a different p so even though it looks like a trivial rescaling that should drop out in the end it parameterizes the function space the Hilbert space of functions should use for finding the solutions so in this sense it is a physical parameter that belongs to the definition of your theory okay and so the good news is that you can have theories that have the correct Higgs to W boson mass ratio so there are trajectories that connect the Gaussian fixed point to the physical parameter space you're interested in and this is all you can expect and just to check so in the standard perturbative line of reasoning you have the Fermi scale the vacuum expectation value the Higgs mass and the W boson mass as physical observables and in this system here we have this relevant mass parameter which is kind of normal you have the marginally relevant direction which is kind of normal also from the Gage perspective and then these two further parameters are kind of exactly marginal you choose them this defines your theory of the game but there are two of them and with these you can just fix the theory you would like to have okay so conclusions the standard statement that non-Abelian Gage theories for any SUN are not asymptotically free I think is not complete the statement is only complete once you fix the boundary conditions for your effective action for your correlation functions and I claim that there are boundary conditions which are kind of natural including log-like singularities which allow for trajectories that are asymptotically free so in this sense even a non-Abelian Higgs model can be asymptotically free and UV complete as Francesco pointed out which is an important criterion so I just told you that this is that this holds for the non-Abelian Higgs case but you can also include fermions and play the same game and it seems that the same structures are at work and so we have found no criterion that rules all these log-like singularities they should be there but of course it might be that one of you has a good physical reason why one should exclude this type of solutions from the physical parameter space or physical function space and if so then that would reduce the type of solutions you have so my message to you working on very different fields gravity, condensed metaphysics is you should really take the boundary conditions for the flow equation seriously and really explore which boundary conditions are physically meaningful in many cases it's obvious but in other cases it might not be so obvious and as this example should tell you in some cases it makes a decisive difference for the properties of your theory so that's all