WH11NE- Sunrise: It's not new.
WH11NE- Sunrise: Okay? Thanks for having me. This is.
WH11NE- Sunrise: I'm happy to finally talk about this stuff. I've been working on this for
WH11NE- Sunrise: a while now it's been slow going. I think I had the plots in the paper done, maybe 6 months ago, and I think the writing has been slow, but
WH11NE- Sunrise: be glad. I'm just kind of talking. Just let people get into this, anyway.
WH11NE- Sunrise: so yeah, let's just get started.
WH11NE- Sunrise: So this talk is about negative weeks problem and how to solve it. And so just a quick introduction, how do you handle negative weights and analysis? Let's say you're doing a histogram, a regular histogram, where every week event comes with the same week. You just count the number of events you need to PIN, and that's your estimate. And then you have multiple uncertainties on that.
WH11NE- Sunrise: But you can have video instagrams.
WH11NE- Sunrise: They're handled like normal, except instead of everything giving the same amount of contribution. You just have a weight attaching to them. And that's how you. It's just formula to count the total weight that ends up in a given PIN.
WH11NE- Sunrise: Right. And this is the formula for the Monte Carlo uncertainty or the
WH11NE- Sunrise: statistical uncertainty on your estimate right?
WH11NE- Sunrise: These weight can also be negative. We'll talk about why that happens later.
WH11NE- Sunrise: And but the way you use them is
WH11NE- Sunrise: just like before, except these weights could be negative. Since you, you still need to add up all the
WH11NE- Sunrise: the contribution from all the events in a given bin, and that's your estimate, and so on, and you have your histogram uncertainties, and so on. Right now we know that the distribution of physical observables have to be non negative.
WH11NE- Sunrise: But
WH11NE- Sunrise: and so like, if you plot a physical, variable, and and have infinite statistics, and so on. All of these will end up being
WH11NE- Sunrise: positive overall. But you still end up with database, and that's just an artifact of the payment formulations that you use to produce these links right
WH11NE- Sunrise: now, why are negative reach bad? If you look at this you'll see that as the variance of reads
WH11NE- Sunrise: increases
WH11NE- Sunrise: your uncertainty blows up. And so your sample efficiency drops right? So variance in general is bad.
WH11NE- Sunrise: but variance from negative weights is particularly bad, because you cannot unweight it away before you do the more complicated, more computationally expensive parts of your simulation. Pipeline, so unweighting is something you can do after event, generation to remove the weight variance, but that only works for
WH11NE- Sunrise: eliminating the variance month's positive events and months negative events.
WH11NE- Sunrise: You can change the sign up rates, basically right? And so this is particularly bad. And don't quote me on this, but I've heard that this costs Cms at the end. See tens of millions of dollars, and I don't know if that's what C and so on. And this is a problem that's gonna be. They're not just for, but also future colitis, and so on. So
WH11NE- Sunrise: it's an important problem to solve.
WH11NE- Sunrise: It's also a difficult problem to solve. And I base this just on the fact that it's been around for a long time. People have been trying to solve this problem. But there's only so much right
WH11NE- Sunrise: now, the claim here is that it's just. I have a relatively straightforward solution to it. If we just implement the solution, it will work, and it will bring down the negative reads and so on. Right? And so the goals for this talk
WH11NE- Sunrise: to introduce what the technique demonstrate it with a simple example.
WH11NE- Sunrise: And then I want to convince you that this technique can work for other processes as well, and
WH11NE- Sunrise: maybe explain how arcane sites to the difficulty. Like, if there's a simple
WH11NE- Sunrise: quote, unquote, simple solution to a difficult problem, there's got to be some rationale for it, and without that I cannot convince that it works for any situation, and just to set the expectation for this talk. There's not gonna be a lot of physics theory here. And so further with Qcd. Matching and merging prescriptions, Mcnlo power head and so on. So if you're into that kind of stuff. This talk is not gonna scratch that itch. On the other hand, if you're into
WH11NE- Sunrise: machine learning and neural networks and all that stuff.
WH11NE- Sunrise: This talks not gonna have much of that either, but we will have. We will have some one dimensional fits right?
WH11NE- Sunrise: So where do the negative weights. Where does the like? So after actually, without getting into the theory of things negative weights, problem shows up because the same
WH11NE- Sunrise: practically identical event
WH11NE- Sunrise: could come through different pathways. In your event, generator, right event, generator consists of a bunch of random decisions that you take.
WH11NE- Sunrise: and each of those leads to the final event that you end up with. So you can end up with the exact same practically identical event, but through different generator pathways
WH11NE- Sunrise: and some pathways can give you a faster contribution. Some pathways can give you an idle contribution.
WH11NE- Sunrise: but the way we sample them is some events capture some pathways. Other events capture the other pathways. And so they have to come with the respective sign of the weights. Right? A simple example. And this is kind of what we're gonna cover in the
WH11NE- Sunrise: in this talk for e plus e minus goes to Qq. Bar plus one J. Events at Nnl. Accuracy, the Mcnlo procedure is to do it like this, you say, choose the event to be of either H or S. Type H is hard remainder. S is standard. These are just terminology in the Mcn formalism. If you choose it to be of H type, you sample, resolve it. Event
WH11NE- Sunrise: Qq. Bajean.
WH11NE- Sunrise: If not, you'll sample an unresolved event. Qq. Bar. But then you get to also. These events come with an event specific starting scale for the bottom showers. You perform the showering, and you'll end up with a final event with Qq. Bar, plus a bunch of jets or box and gloves right
WH11NE- Sunrise: notice that you can end up with the same event through different stuff like you could start here or you could start there, and you can end up with the same event. And that's an example of of how different pathways can lead to the same event.
WH11NE- Sunrise: Yeah, that's any questions so far.
WH11NE- Sunrise: Okay, so before we get start. So the way we're going to deal with this is by moving some contributions from some pathways to other pathways.
Stephen Mrenna: Just a comment. Maybe you should explain what resolved and unresolved means.
WH11NE- Sunrise: Here for the purpose of this talk. Resolve just means that you've already produced the 3 particle event that you're trying to produce at Mcn, at Llacy, and resolved means that you've only produced the 2 2 jets, and it's yet to be resolved into a 3rd
WH11NE- Sunrise: article.
WH11NE- Sunrise: Is that.
Stephen Mrenna: For me. I meant for the audience.
WH11NE- Sunrise: Like, you're greatly like at the Lhc level. Right?
WH11NE- Sunrise: What was that like at the Lh level? Yeah, not at the experimentally measured. What sort of guarantees does this make on the accuracy of the or essentially the accuracy of the 1st emission from the shower? Monte Carlo perspective in terms of it being leading log next to leading log, etc. I imagine that depends on the implementation a little bit. But
WH11NE- Sunrise: yeah, is there anything in this basic diagram here that determines the accuracy that you eventually get from your treatment.
WH11NE- Sunrise: So
WH11NE- Sunrise: this is a good question. And this is this is a good way to set the expectation for the talk. The way to think of this is, you start with an image generator and you modify the reads.
WH11NE- Sunrise: and the goal is, whatever accuracy you have with the original generator have the exact same accuracy. You do not introduce any new biases. So if you started with Mcnlo. That has some distribution for the events, and you end up with the exact same target density for the distribution for the events. If you start with power head, you end up with the exact same. The hardest emission or things like that are preserved all the way through this. Okay? Yeah.
WH11NE- Sunrise: Oh, that's a good good question. So just some background annotation.
WH11NE- Sunrise: If we sample an event X, comma. WW. Is the week.
WH11NE- Sunrise: we will say that this models a quasi distribution
WH11NE- Sunrise: if this property is satisfied, so you take the probability of getting an event without any weights, multiply it with the expected value of the weight for that event, and you end up with something. And this you can think of as the weighted distribution. Right?
WH11NE- Sunrise: so this satisfies one, the 3rd Kolmuggler axiom. So you can have. You can think of conditional probabilities and marginal probabilities, and so on. But it doesn't integrate to one, and it doesn't have to be non-negative. That's the only difference. The weights, because the weights can be
WH11NE- Sunrise: positive or negative, and the weights don't have to be have. Don't have to average to one right.
WH11NE- Sunrise: And the second thing is
WH11NE- Sunrise: You can think of pathways in an event generator as latent information. Right? Let me represent the event and event attributes visible to the subsequent stages of the generation. Pipeline. What I mean by that is.
WH11NE- Sunrise: you take your event generation, pipeline, starting from nothing all the way up to
WH11NE- Sunrise: recall level information. Right? You have this giant pipeline at any point you can cut it and say, what are the information that the subsequent stages
WH11NE- Sunrise: use from the 1st one? Right? And so if you stop it at particle level in generation, it's it's the momentum, and the and the flavors, and so on of the particle level.
WH11NE- Sunrise: event, please go earlier, and so on, right
WH11NE- Sunrise: So that's V is not actually experimentally observable. It's it's just like a
WH11NE- Sunrise: yeah, it's visible to subsequently. L represents all other random attributes that you will not use subsequently. Right? And so if you've made a decision of going to H. Or S, that is not something that will be used at the analysis level, or even past the Mc. And a low level. But it is a random decision that you made, so that goes into L,
WH11NE- Sunrise: and so V comma L. Fully Ca-characterizes the pathway within the event. Generator
WH11NE- Sunrise: right? And the way we sample the goal of the inventory can be thought of as you're trying to sample some from some fob
WH11NE- Sunrise: by 1st writing it as F of L. Integrate over L. This is an aggregation over all possible pathways.
WH11NE- Sunrise: Right? And why do we have it written this way. It's because we don't have close form expressions for. But we do have close form expressions for F of P. For mile.
WH11NE- Sunrise: right and just to give you a quick example. This is a screenshot from
WH11NE- Sunrise: a part of our introduction from by Stefan. And so
WH11NE- Sunrise: this complicated and so we're going to treat this as a diagram as a picture, and just like, observe some patterns in different places, right? So on the left hand side, you're trying to estimate the expected value of some observable
WH11NE- Sunrise: right.
WH11NE- Sunrise: And this observable could be, how does this event end up in a particular bin of your final analysis, and so on. So this could be the expected number of events normalized to the cross total cross section, and so on. Right?
WH11NE- Sunrise: And if you look at this. There's this O. Of P. And O. Of P. That
WH11NE- Sunrise: captures whatever happens beyond
WH11NE- Sunrise: the event, generation stage represented here. So the whole purpose here is to produce an event with momenta, with a bunch of particles, with specified momenta, and those will undergo patronization, detect assimilation, and and so on. Before you end up with your final analysis. So we're not gonna worry about that. But that becomes our visible attributes in this diagram, this P, that's your visible attributes.
WH11NE- Sunrise: So if you look at the 1st
WH11NE- Sunrise: line here, this is a way to produce n particles first, st and then attempt a part on shower, and if there are no successful emissions.
WH11NE- Sunrise: then you just send that n particle event away.
WH11NE- Sunrise: If there is a successful emission, then this
WH11NE- Sunrise: says, perform an emission, and then send it subsequently. And this is your each event that directly samples and plus one particle final state, and so on. So this is what I mean by this.
WH11NE- Sunrise: It's just a simplified notation of writing
WH11NE- Sunrise: of like abstracting out the formulas that you see in and so on. Right?
WH11NE- Sunrise: okay. So now, in this language? What's the negative? Each problem. The negative problem is, even if F of V is not negative. F of b comma, l can be negative. For some values of V and L, right? And so that's the negative problem.
WH11NE- Sunrise: So in this language, how we solve this problem from the theory side.
WH11NE- Sunrise: you say, well construct a different FF. Prime, that does not have this problem right?
WH11NE- Sunrise: You could use different latent variables. It doesn't have to use the same latent information, but just construct something else that does not have this problem, but also approximately matches
WH11NE- Sunrise: the original things up to whatever accuracy you want. So it could be like up to another accuracy up to a low accuracy, and so on.
WH11NE- Sunrise: And a lot of theory approaches. Following Mcelta. This is more recent. They all fall under this category, which is, how do we modify our theory? Descriptions?
WH11NE- Sunrise: To get the same accuracy, to get predictions of the same accuracy without the negative reach problem or with reduced negative weeks problem, right? But this has been difficult.
WH11NE- Sunrise: Constructing such things has been hard, right? If we have time, I'll talk about? Why, it's been hard. Right?
WH11NE- Sunrise: So then, how does Arkane deal with this problem? Arcane says.
WH11NE- Sunrise: That's what you want to. That's the that's what the theory gives you.
WH11NE- Sunrise: Just add another term Gfp. Comma l. To it.
WH11NE- Sunrise: So this is your quad density under our Knb. For Vl. Vnl. With the property that if I aggregate over all possible pathways
WH11NE- Sunrise: gop cancels out for every single week, right? So I fix a week.
WH11NE- Sunrise: look through all possible pathways and see how this G.
WH11NE- Sunrise: what contribute like average out the contributions from G that has to go over with this constraint. I have constructed
WH11NE- Sunrise: an FR. Team. That is exactly right. This seems like too simplistic, right? Like
WH11NE- Sunrise: this can't be the solution. But this is kind of what our team does. Right? So there are 2 questions here. One.
WH11NE- Sunrise: how does one construct the redistribution function? Be right? Like, you need to
WH11NE- Sunrise: like TV gives you that. Who gives you that?
WH11NE- Sunrise: Right. So somebody had like, you need to figure out how to construct that G,
WH11NE- Sunrise: and then the question is, how do you sample from?
WH11NE- Sunrise: We have an event generator given to us that can sample from this F of from this F, we don't know how to sample from F plus G. Right. Now, let's tackle this second problem first, st and then we'll get to the first.st
WH11NE- Sunrise: That's a good question. Yeah. I assume there must be some statement about the desire to have Frc, be greater than or equal to 0. Right?
WH11NE- Sunrise: Yes. Is that just? That's just true is like what the goal of this is that G satisfies this and Frc. And is greater than equal to 0. That's a good point like
WH11NE- Sunrise: what we want to do with this is not just like we can. Also, you can just make G equal to 0. And that satisfies all of these. But you want the G
WH11NE- Sunrise: to move contributions
WH11NE- Sunrise: of different pathways to the same B, basically so, and you want to do it in such a way so as to get rid of the negative expo. It's a good point, right? Yeah. G, redistributes contributions. And there's a an added bullet here of there's an optimal g
WH11NE- Sunrise: that can actually get rid of the negatives problem. And an interesting point here is that
WH11NE- Sunrise: you can say, what is the optimal g, the optimal g is the one that makes all the weights the same
WH11NE- Sunrise: for all L for a given B,
WH11NE- Sunrise: but that is a much harder like. You don't even need to go there. What you said of like just make the science positive. That's good enough, and that's a much bigger than
WH11NE- Sunrise: condition to satisfy. Turns out
WH11NE- Sunrise: so let's answer the second question. First, st how do you sample events from Fr. King.
WH11NE- Sunrise: The usual way we deal with this the usual way we deal with sampling from 2 terms like this with a plus and the PIN. This is exactly the form you have inno, by the way, you have some term with for s events, and some term for each events right.
WH11NE- Sunrise: and the usual strategy is to say, sample some events from the 1st term and some events from the second term right.
WH11NE- Sunrise: But that is not going to help us here, because if we sample some events from the 1st term, and some events from the second term, we have a new leading variable
WH11NE- Sunrise: that tells us which term the the event came from
WH11NE- Sunrise: right, and the events that come from the 1st term will continue to have the same fraction of negatives. They all already have.
WH11NE- Sunrise: and the events coming from this new term will have 50% negative weeks. Once you unmute them because they need to average to 0. So you're just like adding 50% negative weights
WH11NE- Sunrise: and not solving the original problem either. So this whole thing doesn't help
WH11NE- Sunrise: right? And so this is where Arcane comes in.
WH11NE- Sunrise: because we need each event to have contributions from both terms. And you do this by this a little re waiting where you say sample from F. Don't worry about G, for now, sample from S, you have an original weight
WH11NE- Sunrise: post sampling computer correction like this G over P.
WH11NE- Sunrise: Where P is the probability of the pathway represented by Guma health?
WH11NE- Sunrise: Any questions at this stage?
WH11NE- Sunrise: Yeah, how does this behave? If you have an induced radiation 0 in like the next leading order process that's not present in the born diagram.
WH11NE- Sunrise: Like, if for some reason like going to next leading order causes you to have a region of phase space where there's a 0 weight
WH11NE- Sunrise: where, where, where? There's a like after you do the integrals, etc, where there's a 0 weight that wasn't there in the born diagram. You're trying to reconcile these 2 things.
WH11NE- Sunrise: Maybe I'm thinking about. P goes to 0 is a problem. Yeah, yeah, exactly. If he goes to 0, what happens?
WH11NE- Sunrise: The expectation here is that P,
WH11NE- Sunrise: we'll have sufficient coverage for F, right? We are not modifying the event generation. This is a good question, and I don't have slides in the talk covering this part. That's a it's an interesting question.
WH11NE- Sunrise: which is, what are the conditions that gene needs to satisfy, for the weight to all be finite. And for there to be no coverage issues.
WH11NE- Sunrise: Okay?
WH11NE- Sunrise: And
WH11NE- Sunrise: the way to think of it is like. First, st let's ask, what is the condition on P for there to be no coverage issues. P needs to Co cover F complete
WH11NE- Sunrise: right and
WH11NE- Sunrise: Now the new constraint is P needs to cover G completely.
WH11NE- Sunrise: which you can satisfy by saying that g
WH11NE- Sunrise: should be completely covered by this.
WH11NE- Sunrise: If G is 0 wherever F is 0, we don't have to worry about coverage anymore.
WH11NE- Sunrise: Okay.
WH11NE- Sunrise: be just because the original event generator was able to sample from F properly. And so if we as long as we stick to a subset of points where F is
WH11NE- Sunrise: not 0, then this will sample it properly.
WH11NE- Sunrise: Okay, that is an added constraint on.
WH11NE- Sunrise: So you you fix the coverage and kind of some of the phase based structure by choosing an app essentially, or by by defining that. Okay, gotcha
WH11NE- Sunrise: So this is just actively waiting. And and
WH11NE- Sunrise: if we look at this equation, F original is just the original way to live in. We have that. What do we need to compute the rest? We need? B,
WH11NE- Sunrise: and we need L. So L was latent information that usually you don't need to do the analysis to do subsequent simulations, and so on. But this is some added information that needs to be tracked. You need to say whether the event came from S or H. And there's gonna be some more latent information that you'll see right.
WH11NE- Sunrise: And then comes the big problem of like what's
WH11NE- Sunrise: and constructing such a good G is crucial for the success of parking. And I'm just going to say it's not. It's not gonna be too hard right.
WH11NE- Sunrise: and and this should be suspicious, because
WH11NE- Sunrise: few slides ago I said that constructing an F. Prime is hard.
WH11NE- Sunrise: And now I'm saying right, F. Prime is f plus G, and constructing a good G is not too hard, right?
WH11NE- Sunrise: And there's also already been a lot of text.
WH11NE- Sunrise: And so we're gonna see an example, and then, if there's time you'll get to, why.
WH11NE- Sunrise: it is not too hard to construct what? In what way it solves the it over it sides a problem that other things experience. I digress, but too hard is very different from easy. You will see how. Yeah. So
WH11NE- Sunrise: I don't want to call it easy, just because I've done it for one process, right? Can't be like, oh, I saw this simple problem. Now, I'm gonna call that. Say that everything is easy. So
WH11NE- Sunrise: it's but I do think it's
WH11NE- Sunrise: what's the word tractable. It's a tractable problem. Okay? So this is just the same picture we saw from before. This is like the general flow chart. And this is the example we're gonna solve e plus e minus goes to QR plus one jet. There's a lot of details that are missing here, but this is the rough flow where you go from. You pick Hrs. It's h you get Q bar, G, it's SQ. Bar. And then you perform pardon
WH11NE- Sunrise: step can include multiple emissions right? But we're gonna stop this. We're gonna kind of break this apart
WH11NE- Sunrise: at the point where, from the 8 side, you have Qq. Barji from the S. Side you either have no emissions, or you have one emission.
WH11NE- Sunrise: and then we'll just stop. We won't look beyond that. We'll stop there, and we'll perform our debating at that stage before continuing with the rest of the showers right? And so for this step. This is what the flow chart for the s pathways look like. Now, I'm just zooming in on the right side of this
WH11NE- Sunrise: of this verification. So it says, sample
WH11NE- Sunrise: so you say, sample and e plus C minus. Go to Qq bar. You also have
WH11NE- Sunrise: a starting scale for your emissions.
WH11NE- Sunrise: And this flow chart covers the part on chart algorithm called V, 2 algorithm, right? The way it works is you sample a proposal for an emission.
WH11NE- Sunrise: and if that proposal is greater than your cutoff scale, you say, we're not gonna be able to do any emissions end and just return the unpresolved event that you have right. On the other hand, if it is not less than the cutoff scale, if you're still above the cutoff, then you do an accept, reject, and this is the veto algorithm part coming in. You do an accept, reject. If you if you accept that emission proposal, and you perform the emission which gives you your
WH11NE- Sunrise: e plus e minus plus q bar plus g right.
WH11NE- Sunrise: On the other hand, if you reject it, then you go back, sample a new proposal.
WH11NE- Sunrise: same thing over and over again, and so you can have different sequences of rejected proposals before something is accepted. And this is important here. Right? These rejected proposals are hidden. They're latent it doesn't matter for the subsequent processes, but it does exist, and we need to be able to kind of move contributions across these different sequences of rejections right?
WH11NE- Sunrise: Anyway. So this is also a lesson in how
WH11NE- Sunrise: works, because I think a lot of us don't know this stuff or unwaiting. And ll, yeah.
Stephen Mrenna: Supersant.
WH11NE- Sunrise: Yeah.
Stephen Mrenna: So this veto is coming about because the the Parton shower doesn't have. The pseudocop doesn't have
Stephen Mrenna: an easily invertible Cdf, right?
WH11NE- Sunrise: Yep, good.
Stephen Mrenna: If you had a shower that had a easily invertible Cdf. With this there would be no problem with weight, with negative weights.
WH11NE- Sunrise: No.
WH11NE- Sunrise: So that is a good point like we won't have. We won't have the issue of multiple
WH11NE- Sunrise: latent projections that we performed right. But it's not that this will get rid of the negative weights problem itself, but it does.
WH11NE- Sunrise: It will make the native weeks problem a lot easier than it is right now, and I'll talk about that when we get there. In a few few slides on the line. I'll talk about the implications of
WH11NE- Sunrise: splitting kernel that is easy to invert, and so on.
WH11NE- Sunrise: But that's a good question. If you had something like an analytic Pdf or something you could just solve where you don't solve for where you don't get negative weights and use that
WH11NE- Sunrise: instead of needing a machine learning algorithm to do it.
WH11NE- Sunrise: Oh.
WH11NE- Sunrise: yeah, something like that. Yeah the other. The way I think about it is, if you did not, if you had an invertible splitting kernel, you won't need a beta algorithm. You can just simulate the emission in one step. And now it's just 2 terms, one term for producing a 3 particle event from H, and another for producing a 3 particle event from S,
WH11NE- Sunrise: and
WH11NE- Sunrise: moving contributions around. There is so simple. Right? You just add a, you say, plus 3 minus 3 or plus f of x minus F of X, and that is an easy way to move contributions around. The problem is, and this is kind of like jump going back to what I was saying about like, why negative? 8 problem has been difficult. It is when you remove something from the 8 side.
WH11NE- Sunrise: How do you insert it to the 8 s. Side, so that the cancellation happens for all the events?
WH11NE- Sunrise: Because, yeah. But yeah, both of these are good points that I will address later.
WH11NE- Sunrise: So for the age events, I said, you will produce a Qq. Buddy.
WH11NE- Sunrise: But in the tutorial that I was following, this is a tutorial. This is all based on a tutorial for Stefan, and in that tutorial. The way it was done is
WH11NE- Sunrise: you need some way to get to a 3 particle final state right? And they do it by saying, 1st sample, Qq. Bar. A 2, 2 particle final state, then pick one of the 2
WH11NE- Sunrise: channels of emission, which is either Q, and it's the G or the Q bar image G, so you have 2 options there, and then you have to sample some emission parameters that's the YZ. Phi, and so on, which parameterizes the angle scale, and so on. So you use all of those to perform an emission, you get your Q bar G,
WH11NE- Sunrise: then you you still need to figure out where to start the emission for the next
WH11NE- Sunrise: a bit to start the scale off for the next emission. And here you do some math where you say
WH11NE- Sunrise: if
WH11NE- Sunrise: you you sample a. C 4. Scale. If you assume that it came from one of the channels, you have a certain
WH11NE- Sunrise: starting scale. If you assume that it came from the other channel. You have a certain starting scale, and these have nothing to do with the actual channel we used to generate, and so on. These are just like logistics of the process. But this is what the flow chart looks like.
WH11NE- Sunrise: and there are some just something to observe. Here we have an edge case here where?
WH11NE- Sunrise: if something falls below certain, cut off, then you set the event rate to 0, and so on. So there's a bunch of edge cases.
WH11NE- Sunrise: But leaving those aside, if we end up with a Qq. Bar
WH11NE- Sunrise: G event, that doesn't fall into any of the edge cases, that what? That's what this class one or 4 means. It means that
WH11NE- Sunrise: there are contributions from both S. And H. Branches to this one given visible
WH11NE- Sunrise: event right? What are all the histories that a given event with a particular set of final state momenta could have come from right? Well, we can broadly classify the histories into 2. It could have come from the H. Histories or the S. History
WH11NE- Sunrise: right if it came from an Hstry. Again, there were 2 options for emission channel.
WH11NE- Sunrise: So something to notice like this is not necessary. A lot of there are ways to produce a 3 particle event without going through those 2 channels and so on. But we'll just keep that because it helps a nice warm up exercise. We'll see that in a second.
WH11NE- Sunrise: So there's 2 strands like that and the Ss. Trees.
WH11NE- Sunrise: You have a continuum of
WH11NE- Sunrise: Ssp. Corresponding to the same visible event. And what is what do these correspond to it corresponds to all those rejected proposals that you have right. You could have had no rejected proposals, or you could have one rejected proposal with some value.
WH11NE- Sunrise: For the
WH11NE- Sunrise: parameters, and or you could have 2, 3, and so on, so you can have up to N. Rich. The N rejection is the number of rejections. Right?
WH11NE- Sunrise: And so this is the kind of thing
WH11NE- Sunrise: scheme of his, like sequence of, or like
WH11NE- Sunrise: chronicopia, histories corresponding to a single visible event. Right any questions at this.
WH11NE- Sunrise: Okay.
WH11NE- Sunrise: so we need a strategy to move things around. And the strategy is this, first, st as a warm up.
WH11NE- Sunrise: we'll just merge these 2 strands together. What do I mean by merge? You say? Take that total contribution, and redistribute it so the weights are the same
WH11NE- Sunrise: right, not only that add up their probabilities.
WH11NE- Sunrise: So then we can completely cut off these 2.
WH11NE- Sunrise: We can just cut off these 2 and 3, the entire Hs 3. As a single strand. What determines whether something counts as a strand or not
WH11NE- Sunrise: is.
WH11NE- Sunrise: if it has a well defined weight and a well defined probability that you can compute, there's no so if I stick within these solid lines, then the weights could be different. Within each of these solid lines the weights could vary, but once I hit the dashed lines, the weights are the same.
WH11NE- Sunrise: and I can compute the probability just by multiplying the probabilities of all the decisions in my human generator.
WH11NE- Sunrise: and you can make this each
WH11NE- Sunrise: solid line into a dashed line just by merging the 2 right? So that's a long and the hardest stuff is, how do you move stuff from H. To S. And how do you redistribute it across the different
WH11NE- Sunrise: S branches? Right? And so we'll get to that. So the so the way to redistribute things across 2 strands, history strands.
WH11NE- Sunrise: Let's say we have an F.
WH11NE- Sunrise: That is a sum of 2 contributions. Z is the leading table that tells you which one it is, and we have a. We have probabilities for sampling those 2, and so on. The optimal weight.
WH11NE- Sunrise: meaning the weight that makes both of those equal pub.
WH11NE- Sunrise: The waiting scheme where both channels will get the exact same weight, is just like, take f divide by T right, and that's what you get here.
WH11NE- Sunrise: You just add the both contributions and divide by the probabilities. But now I'll just write that as P. Times, W. There are S. Is P. Times, W. And something interesting happens here in this equation.
WH11NE- Sunrise: which is now I don't have to think about the physics at all right
WH11NE- Sunrise: in the 1st line for W. Star. I have F's in there and F's capture the physics.
WH11NE- Sunrise: but in the second line I can just think in terms of the generator that's given to me. It has probabilities to do different things, and it assigns different weights to them. I'll assume that the generator gets the physics right, and I can just work with the probabilities and the weights under a given generator. Right?
WH11NE- Sunrise: And this kind of a redistribution will be achieved by setting. Well, I want post re weaving with a G. Star. I need the weights to be W. Star, and you put things in. And this is the kind of formula you get.
WH11NE- Sunrise: Kind of rough. Roughly observe the structure here. It's a probability of product of probabilities in the denominator, and you have F. Times P. And P. Times, F.
WH11NE- Sunrise: But the minus sign and
WH11NE- Sunrise: 2, 1, 1, 2, right. It's just kind of roughly observe this, and this is the easy, warm up thing where we just say, Look, there are 2 branches. How do you redistribute? Right?
WH11NE- Sunrise: Yeah, this is the contribution. You move from one branch to the other.
WH11NE- Sunrise: Bye, now the rest of it.
WH11NE- Sunrise: considering the time I'm going to
WH11NE- Sunrise: only be able to explain reading right? There's gonna be some screenshots of equations from the paper, and we're again going to treat them as pictures diagrams and just observe certain patterns, right of what's going on
WH11NE- Sunrise: right. The redistribution strategy we talked about there of. Take something there from each
WH11NE- Sunrise: drop around S and redistribute. It will be accomplished by this
WH11NE- Sunrise: idea where you take Lambda V. From the H. Branch, and you dump it on the S. Branch, and then you redistribute it across the list of rejected proposals where list of rejected proposals is a continuous variable with different number of inputs and so on. It's complicated. But Phi UN has to be unit normalized for this to work
WH11NE- Sunrise: right?
WH11NE- Sunrise: Any questions here.
WH11NE- Sunrise: So what we're doing right now is going through the process of constructing
WH11NE- Sunrise: a redistribution. G. That we talked about the one we said that I claim is not too hard, right?
WH11NE- Sunrise: And so the thing to notice here is how systematic and methodical it all is right. You just kind of go through the motions, and we are able to construct things right?
WH11NE- Sunrise: So the next question is, okay, I have a lambda. 5 UN UN stands for unit non voice. What should they be?
WH11NE- Sunrise: FNBL.
WH11NE- Sunrise: Oh, but that's that's the secondary question. The question
WH11NE- Sunrise: FV. And S. That's the thing that can be negative. Is that correct?
WH11NE- Sunrise: So the H is positive generally, or always so. In this example
WH11NE- Sunrise: S is always positive, and H
WH11NE- Sunrise: can be positive or negative, depending on input
WH11NE- Sunrise: in general for Catron
WH11NE- Sunrise: processes, both of them can have negligence.
WH11NE- Sunrise: Just this one example I'm solving. It turns out that if for s events, it's plasma.
WH11NE- Sunrise: So.
Stefan Hoeche: In practice for most of the Lhc applications. H is typically the big problem. H is the the culprit that generates most of the negative rates.
WH11NE- Sunrise: Oh, okay, so I always attracted.
WH11NE- Sunrise: let's just assume Lambda's negative. So.
Stephen Mrenna: Where does the.
WH11NE- Sunrise: Yeah, so.
Stephen Mrenna: Where does the negative delta function? Pop up in the h or the S.
Stefan Hoeche: Typically in the age. And the problem is that the age events are computed as a difference between the real emission matrix element and the either Katani simo, or fixed unicorn signal counter terms.
WH11NE- Sunrise: Wow!
Stefan Hoeche: So what happens is that you typically get an over subtraction because an approximation to the matrix element. And typically it's it's an overall approximation. Right? So it's correct in the infrared limits.
Stefan Hoeche: But in the finite region it's typically over subtracting.
Stephen Mrenna: Good.
Stephen Mrenna: Thank you.
WH11NE- Sunrise: So going back to Nick's question of what does Nbo stand for?
WH11NE- Sunrise: So
WH11NE- Sunrise: I said that the part where the 2 each strands get merged. It's not like particularly interesting and so on. And that is stuff that you expect
WH11NE- Sunrise: production quality. So the merging of the 1st step here. That is something you expect for production quality when they're interested. And so Nbm is the new baseline where you start with original. And then you do this merging.
WH11NE- Sunrise: and so the S. Weights did not change, and the H. Weights did change.
WH11NE- Sunrise: And now, whatever we select I call that new baseline in the paper. And this, it's an this is an artifact of screenshotting the paper for the patients. Yeah.
WH11NE- Sunrise: okay, yeah. And the reason
WH11NE- Sunrise: the reason this is negative. And like there's a negative on the H side is because I wanted to be able to write the redistributing lambda V across. S.
WH11NE- Sunrise: You can do that if there's a minus on the on the second link that it's just yeah.
WH11NE- Sunrise: So the next question again is like, Okay, what what is lambda? And what is 5 supposed to be.
WH11NE- Sunrise: and the approach here is, do the same thing as before, right? Like to find out what lambda is the same thing as before. You have 2
WH11NE- Sunrise: branches. What should the contributions be? So that's the optimal lambda star.
WH11NE- Sunrise: And again treat it as a picture. Kind of think back to what we did for the 2 branches. You have products of
WH11NE- Sunrise: product under
WH11NE- Sunrise: you have.
WH11NE- Sunrise: Yeah, this
WH11NE- Sunrise: is wrong. It needs to have a plus. I trust the paper equations more than the equations that threw together in the last hour, and then you have F under H.
WH11NE- Sunrise: Times, P. And the rest.
WH11NE- Sunrise: and then you have the flip with a minus sign. So this is just going through the motions of what we did before.
WH11NE- Sunrise: right where this Ps. Is. The probability of this getting this event B
WH11NE- Sunrise: under the S channel, which includes, if you recall, you need to 1st sample, you need to 1st sample this leading order event. And then you need to perform a part on shower. And that's what's captured here. Right? We've just written down the expression, what's the problem? The problem is.
WH11NE- Sunrise: the circle form factor here doesn't have a closed form right
WH11NE- Sunrise: now, going back to what Steve was saying. If we had an invertible cost factor, this is the end of it we can just
WH11NE- Sunrise: have. We have an optimal contribution to move around. We just, we don't have any rejections. We just have a single step. We use this redistribution. And this would never have been a problem.
WH11NE- Sunrise: The problem is, because,
WH11NE- Sunrise: yeah, we don't know how much to move, just because, yeah, I don't know if
WH11NE- Sunrise: this makes sense right. If you just had 2 strands with no other complications, it's easy to move things around, but because we have the part on shower, we have a vita algorithm, and so on. It becomes hard to move from one and throw it into the other is a way to put it that you know, in each case there were just the 2. But in this case it sort of bifurcates
WH11NE- Sunrise: forever in theory. Yeah, although with some vanishing probability that it goes forever. Yeah, it turns it into an integral and almost an optimal transport problem.
WH11NE- Sunrise: So the next question is okay, we, we. Let's just put a PIN on this problem right? We don't know how to compute this. But let's just put a PIN on this, and let's ask the next question, how do you redistribute? What's the Phi UN supposed to be? Again? You can write down the exact expression it's supposed to be because all of this is using the unweighted part on showers
WH11NE- Sunrise: the optimal right thing to do is to distribute it proportional to their probability of occurrence.
WH11NE- Sunrise: You have some big pot. You want to redistribute it equally proportionate to the probability in which each of those trends comes about. And that's what this
WH11NE- Sunrise: giant thing is
WH11NE- Sunrise: delta G times, G is your proposal kernel function, as I call it. But in the algorithm you have a way to propose it, and then you accept or reject
WH11NE- Sunrise: delta. G. Times. G. Is your proposal. Probability
WH11NE- Sunrise: one minus F over G is your rejection probability, and you reject it. Enrich times
WH11NE- Sunrise: before you propose something and you accept it.
WH11NE- Sunrise: But that is the probability of just that one strand you want the conditional probability.
WH11NE- Sunrise: So you divide by. I mean, yeah, you. You also divide by the total probability of finally accepting this specific l.
WH11NE- Sunrise: this specific L, so you divide by that. And this is your just an expression that you have from
WH11NE- Sunrise: just, we do algorithm the theory of it, and so on. Right? And again, we are met with the same problem where everything here is calculable except this Delta F right?
WH11NE- Sunrise: And a solution is holding. Please,
WH11NE- Sunrise: Delta, we replace Delta F with an approximately
WH11NE- Sunrise: right. And we can do that
WH11NE- Sunrise: as long as our redistribution function.
WH11NE- Sunrise: even if it's not optimal, even if it's just close to the optimal. As long as it integrates to 0. We're fine, right? And so the key thing here is
WH11NE- Sunrise: you wanna make sure this, when you approximate this, your 5 and better remain unit envoy.
WH11NE- Sunrise: And so if I throw an approximation for delta F in in just this part.
WH11NE- Sunrise: it's not going to be unit numbers. On the other hand, if I replace all the Fs in this equation
WH11NE- Sunrise: with an H which is approximately F,
WH11NE- Sunrise: then it will remain your non license. So that's what we end up doing, we say, Oh, 5 star! Is that make 5 the same thing with S replaced by each
WH11NE- Sunrise: right. And there's no such limitations on lambda. So this brings us to. So you, you write down the expression for the optimal things, and you just make pragmatic approximations. Keep making sure that things.
WH11NE- Sunrise: You satisfy the conditions that you need to satisfy. And this going back to an earlier question from Nick, this
WH11NE- Sunrise: when the the better. The approximation reach is
WH11NE- Sunrise: the the most the negative. Each problem will be reduced, and and the whole like. The sign, will all be positive, and so on. So all of those
WH11NE- Sunrise: will be captured by how well H. Approximates F. The important thing is, even if H. Is so far away from F, it's it's completely stupid. Even then there's no biases introduced. It's not going to be a good reweighting. It's gonna be
WH11NE- Sunrise: a useless rewating, but it will remain valid. All your predictions will remain valid right?
WH11NE- Sunrise: So once you have. Once you figured out how much to move and how to redistribute it, you just
WH11NE- Sunrise: plug it back and take patience, and you have the formulas for Wr. Team, where
WH11NE- Sunrise: everything here is computable.
WH11NE- Sunrise: As long as you track what the C primes, l primes and Z primes are
WH11NE- Sunrise: meaning, what are the rejected proposals in your room? You track that, and you need to remember which path you came from, of course.
WH11NE- Sunrise: because my weight is not just of V. It's a function of V and the path that I took to get there, and so on.
WH11NE- Sunrise: And the weeds I know, because I can just ask the event.
WH11NE- Sunrise: Oh, something to note here is that even though the 1st equation computes the weight for each.
WH11NE- Sunrise: I'm asking what would be the event, what would the event we have been if it came from S, and so on. So there's like a lot of backtracking through the event generator to use the information there and then plugging into into the formula, right
WH11NE- Sunrise: and if something
WH11NE- Sunrise: to note is that if F. And G. Matched this whole term will get canceled out.
WH11NE- Sunrise: and the 2 will be equal to each other. And that's that's the optimal redistribution where the weights are all independent of the path you could solve equal? Right?
WH11NE- Sunrise: Okay, so I'm going to start speeding up now. So something that I won't go into in detail here is you can do some math
WH11NE- Sunrise: to get rid of the C. And Z. Dependence here, and just write it as Kappas, and for people familiar with the python shower notations, and so on.
WH11NE- Sunrise: So fs my z dependent
WH11NE- Sunrise: splitting kernel. Kappa is my z independent splitting kernel. So you just integrate out the Z in the right limits.
WH11NE- Sunrise: and Delta is my
WH11NE- Sunrise: It is the suitable factor. And
WH11NE- Sunrise: the nice thing is, Delta only depends on F through Kappa.
WH11NE- Sunrise: and so I don't have to approximate F anymore. I can just approximate Kappa and get away with it. And Kappa has one less video. So it's just one less
WH11NE- Sunrise: parameter to fit.
WH11NE- Sunrise: and this is the result of the fitting. What are the different things spotted here? The red, solid curve is the true kernel
WH11NE- Sunrise: function.
WH11NE- Sunrise: Some. There's some equations. You just take it and just fit it.
WH11NE- Sunrise: Kappa. The green dotted line is my approximation for it, using polynomial fits
WH11NE- Sunrise: the the G above. That's the sampling kernel. So you sample using Kappa G, and then you do the
WH11NE- Sunrise: except reject, based on F over G, so that's that. And this dash, dotted or like
WH11NE- Sunrise: dashes of different lens, the horizontal line that's my bad fit, because I wanna show also show that even if you fit this poorly. There. There are no biases introduced, so that's like my bad fit.
WH11NE- Sunrise: and
WH11NE- Sunrise: some like a side note here is that if you notice. There is an M square dependence, dependence on the overall energy of the event.
WH11NE- Sunrise: So it seems like you have to perform this one d fit for every value of M squared, and so on, but by doing some factorization, and so on, you can simultaneously fit them with 2 polynomial fits. You can fit it for a range of M's in one shot.
WH11NE- Sunrise: Right? So you do that you've approximated your kappass. You plug it into the formula, and what happens to the event reads.
WH11NE- Sunrise: So what? Let's see what happens when you go from the original weight to the ndl, this is the new baseline. You have a diagonal line here. Those are your S. Events that were not affected by that
WH11NE- Sunrise: that 1st step. It just changes the weights of the H. Events and H. Events, the weights have been kind of shrunk, the variance has been reduced. And so we start with this better rating as our baseline, and we see what Arcane does.
WH11NE- Sunrise: You see some events? The rates have gone up.
WH11NE- Sunrise: and for some events the weights have gone down, and if you split them into by classes in terms of the agents, gain an upward movement, and the S. Events gain downward movement. There's 2 reasons for it.
WH11NE- Sunrise: One is the fact that each events tend to have the negatives, the other is because each events are kind of underrepresented or
WH11NE- Sunrise: yes, no, they're over represented in the sample. And so because they're overrepresented. The right thing to do is to assign more like move, more contributions to them. But, anyway.
WH11NE- Sunrise: is it the like? The representation depending on what you chose for your like matching scale?
WH11NE- Sunrise: No, so it depends on both things it depends on
WH11NE- Sunrise: in your matching prescriptions. How much do those each events actually contribute
WH11NE- Sunrise: the things, and also, how often are you actually producing them? In your event, generator, you choose the probabilities of various pathways, and if you choose them more than you have to. You end up with them, being over represented in the sample.
WH11NE- Sunrise: and so their rates.
WH11NE- Sunrise: You pump more weeks into them, so that
WH11NE- Sunrise: what they can, what they bring to the table matches, how how often they're sent!
WH11NE- Sunrise: And you'll see that in a subsequent thing. But this far right plot is a poorer implementation of Arcane. You still see the similar trends, but it's not
WH11NE- Sunrise: the 6. Yep 7, Stefan.
WH11NE- Sunrise: You have a question.
Stefan Hoeche: Yeah, sorry. It's not a question. It's just a comment. So the the I think the next question there, there is no matching scale here. Because this is a matching, not emerging.
WH11NE- Sunrise: Oh!
Stefan Hoeche: So if you had, if you if you were to merge as well, though you would have a merging scale, and it would depend on your merging scale. That's right.
WH11NE- Sunrise: Oh, I must have used the wrong word. Yeah.
WH11NE- Sunrise: that's totally possible. I was getting matching and merging
WH11NE- Sunrise: So if you just look at the
WH11NE- Sunrise: number of negative weeks left in me here. This
WH11NE- Sunrise: is the the 4th column here. F. Next, that is the fraction of negative events that you end up with assuming you perform a unwating right? Then, if you do an unwaiting, you go from
WH11NE- Sunrise: around 2%.
WH11NE- Sunrise: It's not much to around
WH11NE- Sunrise: really small numbers, negligible numbers, and an interesting side note here is this, these negatives are not because of suboptimal implementation of arcane. Most of it is actually in the fop. It's just slightly negative in some parts of the space, but the last column here tells you that if you sample around 100 events with the original weighting scheme. It's as good as 90 events
WH11NE- Sunrise: under the arcane. It's almost 100 min right? So it's like, improve the efficiency of the sample. Right. But all of this is useless if you can get your
WH11NE- Sunrise: distributions right? So first, st let's talk about like, let's see how things change right like. So the red histogram is under the original rating.
WH11NE- Sunrise: and the green histogram is
WH11NE- Sunrise: under the arcane reading, and it's kind of moved contributions around for different variables. You have like different mass variables, and in the next slide you have
WH11NE- Sunrise: ferocity and thrust with some
WH11NE- Sunrise: thing like that, the dips at the end of thrust, and at the beginning of sprocity. That's Jacobian factors because of the choice of
WH11NE- Sunrise: takes access. Don't worry too much about that, but
WH11NE- Sunrise: like it's moved some contributions around, but the combined contribution, like in H. And S. Events that stays roughly the same.
WH11NE- Sunrise: And what's part of the 3rd column here is by what fraction. Do you need to increase the amount of events in each bid
WH11NE- Sunrise: in order to get the same error bus? It's like ratio of error. Bus plotted in a like the square, and you see that, and and you can do it with and without waiting is the more reasonable thing to be able to get so in some bins it can be like up to 2 times as much efficiency, and so on.
WH11NE- Sunrise: So that's the point here is that the table that you had showing, you know, going from
WH11NE- Sunrise: 100 events to 90 events isn't the whole story. There's actually differential efficiency that may, for some analysis, be even more important.
WH11NE- Sunrise: But this
WH11NE- Sunrise: in and of itself, doesn't mean that these 2 are corresponding to the same theory. We need to do some goodness of the tests.
WH11NE- Sunrise: and that's what's done here. And here, the way I do business of fit test is
WH11NE- Sunrise: you get rid of the like. Maybe we are. Some things are getting masked by nearly optimal implementation of parking. So you take a terrible implementation of parking.
WH11NE- Sunrise: That's our opinion back. And then to come. You come to compare.
WH11NE- Sunrise: You pick
WH11NE- Sunrise: the original event generator, and produce 10 times as much data. That's what this large corresponds to. The green histograms are made with 10 power. 5 events. The red histograms are made with 10 power, 6 events, and so the Airbars are actually smaller under Nbl large, and you perform a goodness of it test. And I like to look at this version of the statistic. It can roughly be interpreted as being normally distributed. And you see in this plot
WH11NE- Sunrise: almost 3 sigma deviation, which I will attribute the statistical fluctuations because I'm biasing.
WH11NE- Sunrise: But the theory behind the statement, I'll say because there's enough theory to suggest that there should be no biases. I'll say that's a statistical fluke.
WH11NE- Sunrise: and so we get to our conclusions.
WH11NE- Sunrise: Rcvailing can avoid new events.
WH11NE- Sunrise: It does not introduce any biases by construction.
WH11NE- Sunrise: It does not require any changes to physics, formalisms, and we'll see how all of this plays out in a second. And there are some other techniques
WH11NE- Sunrise: like positive resampling, neural resampling, cell resampling, and a few other related techniques with machine learning and stuff.
WH11NE- Sunrise: And there is a problem there that you cannot treat those events as Iid. If you use a bunch of events
WH11NE- Sunrise: and average out there weights locally, you are kind of correlating them. And so they're
WH11NE- Sunrise: so usual formulas we have for a uncertainty, estimation, and so on, will not quite work, so that this does not have that problem.
WH11NE- Sunrise: And so some questions
WH11NE- Sunrise: that I want to talk about, and we have a few minutes. Here is, how do you?
WH11NE- Sunrise: Let's start with this. How does Arkane sidestep the difficulty faced by right. If we go back
WH11NE- Sunrise: here, ask it first.st Yeah.
WH11NE- Sunrise: how does it size stamp? So if you look at this equation right like it's easy to say. Oh, the 1st 3 lines here, that's the S. The last line is the H. Just put a minus
WH11NE- Sunrise: G there, and just put it up somewhere else. It's unclear where you would insert it if you throw it here, if you throw it here
WH11NE- Sunrise: the fight is actually like
WH11NE- Sunrise: the files need to be written, as that's where the algorithms kind of compressions on it has to
WH11NE- Sunrise: let me rephrase it this way. Right? Like
WH11NE- Sunrise: the way we produce events is as forwarding Monte Carlo, where we say, we have a full process to
WH11NE- Sunrise: generate. And I'm going to factorize that as event generation and the detector simulation and and electronic simulation, and so on. And inside detector event generation, you split it into different parts and you keep going further and further, until the individual steps become easy to simulate, and the idea is always you sample from one condition doesn't add you sample another thing, and the weights evolve multiplicatively right. But when we try to make a change to one part of this.
WH11NE- Sunrise: we don't have a good control over how it affects all the events that come at the other end of the pipeline. Right? We change some part on a shower kernel that is going to throw off the distribution of a bunch of final events in a in in an uncontrolled way. Right? So how do you make a corresponding change elsewhere, so that everything gets approximately canceled, and so on. That's difficult.
WH11NE- Sunrise: What Arcane does is, it says, produce the event completely.
WH11NE- Sunrise: and once you know what event you produced, you can isolate the the pathways that lead to that event. And so, because of that, because of that deferred re waiting you have.
WH11NE- Sunrise: you can. All you need to do is some bookkeeping, and you can redist redistribute contributions easily.
WH11NE- Sunrise: And kind of the meta algorithm here of how do you extend it to other processes
WH11NE- Sunrise: is what we've done here, which is just
WH11NE- Sunrise: write down a simple expression for what?
WH11NE- Sunrise: the remaining contributions is supposed to be, which is, oh, integrate over all possible pathways and divide by the probability. And you, you're done like, it's it's it's gonna be. It's gonna start off useless. And then you fill in the details like, what does that look like? What does that integral look like? And it's gonna become this
WH11NE- Sunrise: this kind of a mess? Right?
WH11NE- Sunrise: It's gonna it's gonna be like, Oh, this is the optimal thing to move around. This is the optimal thing tomorrow. So you have a message and you'll say, Okay, I can contribute. I can compute these things easily, and these are the parts that it cannot compute. And then you apply some pragmatic approximations for those. And so this is like a meta algorithm to implement this for different procedures. And this can be extended to negative
WH11NE- Sunrise: part on showers, part on shower kernels, and so on this like, and that I will actually talk about in the conclusions of the paper, and so on.
WH11NE- Sunrise: So it it can just cover a whole bunch of things again. It's not.
WH11NE- Sunrise: I cannot guarantee that this will work, but I think this oops. Oh.
WH11NE- Sunrise: it is very possible that this can be implemented for other process, like when you bring in complications like Pdfs and Isr and negative kernels, and so on. Because I've not tackled it in this paper, I cannot say it will be done right, but I think it can be.
WH11NE- Sunrise: but that has got no questions.
WH11NE- Sunrise: Do we have other questions, bye?
WH11NE- Sunrise: So in the toy example, right? The negative weight fraction in the new baseline. Or, let's say, a typical Monte Carlo. As I understand it.
WH11NE- Sunrise: is 2%, we see, you know in typical cms like, say, on simulations
WH11NE- Sunrise: like 20 to 30%. Right?
WH11NE- Sunrise: Do you know what like, qualitatively.
WH11NE- Sunrise: how those generate more negative ways, and whether there's any expected issues there. Because, let's say, that's that's where the money is at. Right.
WH11NE- Sunrise: So I'll let Stefan answer in a second.
WH11NE- Sunrise: How? Why, those are higher, and so on, because I don't have a handle on that. But I can tell you
WH11NE- Sunrise: one potential issue that can come up, which is.
WH11NE- Sunrise: you should worry about numerics. Here there could be numerical precision issues, and so on, so careful, like numerically stable implementations, and so on. But that will only be an issue, if
WH11NE- Sunrise: even the and like, if you do an analytical review, and you find out the optimal weight and so on. If that is so much smaller than
WH11NE- Sunrise: the average scale of your rates if you're dealing with like. Oh, there's only 2 branches, but one of those is 14, 6, and the other one is
WH11NE- Sunrise: minus 10 power. 6 approximately.
WH11NE- Sunrise: that's not bad. But then, if the rest of the regions are of 10 power, 3,
WH11NE- Sunrise: right? Because 10 power, 6 minus, like. So yeah, there's there could be numerical issues. But buying that.
WH11NE- Sunrise: I don't see anything immediately show stopping. But Stefan can yeah. Go ahead. Step.
Stefan Hoeche: Yeah, I I can explain a little bit of that. If you can go back to the slide with the formula you showed before the one from my tassy lecture.
WH11NE- Sunrise: It's the scariest one in the search.
Stefan Hoeche: I'm really sorry about that. But unfortunately, this is where actually, the problem lies.
Stefan Hoeche: Okay. So if you if you think about the components of this formula. The the most interesting one to look at is the last line, and that's probably the easiest one to read.
Stefan Hoeche: So what do we see there we have a Bn plus one. But this Bn plus one means it's the bomb process for one more jet.
Stefan Hoeche: So you can think of it. As in this example, a qqbar plus blue one which is the real emission correction in the nlo calculation for the.
WH11NE- Sunrise: Okay.
Stefan Hoeche: We typically write this as Bn plus one, because for us it looks like the process with an extra jet and emerging procedure right? But here you can really think of it as real correction.
Stefan Hoeche: So because this is not a merging procedure, there is no merging scale. So we integrate this over the full face space, the full extra emission phase space, which means there are infrared singularities.
Stefan Hoeche: We have to deal with those singularities, and this is what the sum is about the sum subtracts a number of dipole terms, which is why we have that label D for those guys.
Stefan Hoeche: and then D has an superscript, which is ijk, which means we. In these dipole terms, we typically make the approximation that 2 patterns go Collinear. This is the Inj, and then there is a spectator pattern which is kind of the color partner of those guys.
Stefan Hoeche: So we get the soft radiation right?
Stefan Hoeche: And what is kind of gently ignored in here, or let's say it's buried in the definition of the D is that this is a complicated
Stefan Hoeche: interplay between color correlations and spin correlations that enter this d. So there's an underlying born process in there which in our case would be the Qq. Bar.
Stefan Hoeche: The additional gluon is radiated from the Qq. Bar. So this thing in the Collinear limit factorizes into the Qq. Bar process and the quark to quark gluon splitting.
Stefan Hoeche: That is very easy, because the quark has a a color casimil cf, and there's no spin correlation, because commions don't change their spin when the soft gluon is emitted.
Stefan Hoeche: However, when you have a blue one, a blue one has.
Stefan Hoeche: colloquially speaking, 2 colors. So there is correlation with 2 other patterns, and you have to take that into account, which means the factorization is not that simple, and you have actual color correlators
Stefan Hoeche: that make sure that the probability for describing the radiation is correct and correctly takes into account the kinematics of 2 additional patterns and not just the one additional antiquark that's on the other side of the process.
Stefan Hoeche: Moreover, Guan is a vector boson. And for vector bosons, we only have 2 degrees of freedom that propagate in the onshell case. But we have 4 degrees of freedom in the field description.
Stefan Hoeche: So the spin correlations become rather cumbersome to deal with. And this is the problem when you go to higher multiplicity. So this is where the complications come in, because
Stefan Hoeche: these Dipole terms are supposed to approximate the GM. Plus one to a certain degree, in order to make sure that in the infrared limits.
Stefan Hoeche: The square bracket in the last line goes to 0.
Stefan Hoeche: Why? Because the Bn plus one actually diverges, and you cannot integrate anything that's divergent in the Monte Carlo. You can do it analytically. You get your one over Epsilon poles, but you can't do it in the Monte Carlo.
Stefan Hoeche: So these terms, these D's are constructed such that they exactly 0 out the Bn plus one in the infrared limits.
Stefan Hoeche: and there are well defined schemes to do this. One goes by the name of Katani Simon subtraction. The other one goes by the name of pixionicon, signal subtraction, chopper implements. The 1st metgraph implements, the second.
Stefan Hoeche: both schemes, however, are only approximation to the truth in the Bn plus one. And this is again where the negative weight comes from. You see, there's a minus sign between the 2 terms. And you typically over subtract. This is what I what I mentioned earlier.
Stefan Hoeche: Okay, now, because Hadron colliders are a lot more complicated than E plus e minus
Stefan Hoeche: the degree of over subtraction is typically more severe. And this is why you start to see 2030% negative weight fractions.
Stefan Hoeche: When you simulate. Let's say, Td, Bob, plus multi jet at the Lhd.
Stefan Hoeche: so it's essentially it's all a consequence that we don't know d
Stefan Hoeche: well enough to estimate our matrix element, Bn plus one in the region which is not, which does not contain the infrared singularities.
WH11NE- Sunrise: In terms of 2 tickets. Yeah.
WH11NE- Sunrise: Oh, okay, that that helps.
WH11NE- Sunrise: Think I get it early just to test it from another direction. To make sure I get it.
WH11NE- Sunrise: one or one could think about this from the fact that in a real Lhc process like Tt bar plus jets or something like that.
WH11NE- Sunrise: Bn, plus one has so many combinatorics over, you know, color correlations and things like that that the degree of over subtraction from Dn plus one is simply larger and gives you this.
WH11NE- Sunrise: you know, more, 20% negative weight uncertainty.
WH11NE- Sunrise: Exactly. Yeah, that's exactly the way you should think about it.
WH11NE- Sunrise: Okay, your algorithm. You do some fits to some
WH11NE- Sunrise: from kernels. We do not. I do not do any fits to these these B minus V, that just comes from the generator form, that's all hidden in the WI don't mess with it. I only mess with something that goes in the pi. The pi ends.
WH11NE- Sunrise: Is that going to limit the capabilities? Because ultimately you want to be stealing stuff from the B minus d, so so I do. I do have those those are hidden in the
WH11NE- Sunrise: in these. What do you call so here
WH11NE- Sunrise: the W compresses all the physics. But
WH11NE- Sunrise: step on this because right now, right? Right. What is the weight of an event on the S. Path for the wake of an event, and the W. All of that is already in there and post producing the event. I'll just move things around
WH11NE- Sunrise: an easy control map. There. The issue is, you can't just take something and put it somewhere else in the equation because
WH11NE- Sunrise: it influences things in complicated ways but
WH11NE- Sunrise: complicated. But you have an algorithm for describing how it influences. Yeah, yeah.
WH11NE- Sunrise: do you expect this to work whether or not the D over or under, subtracted in some sense. Yeah, well, I mean, you're always adding and subtracting D, anyway. So the degree of over or under subtraction doesn't matter.
WH11NE- Sunrise: So I can kind of list the complications that I have not considered right like in this. In the S diagram you have this bm.
WH11NE- Sunrise: and which actually
WH11NE- Sunrise: like, there's another equation in in the in the paper where Dn is written in terms of some other stuff. So what's gonna happen is, in addition to these diagrams, you'll have another
WH11NE- Sunrise: hidden variable for the S. Histories.
WH11NE- Sunrise: which there was a recent paper that to tackle, that where they said.
WH11NE- Sunrise: This is the bond. What is it called bond spreading?
WH11NE- Sunrise: Pass that one?
WH11NE- Sunrise: Yeah. So they had a way to do it. But you can tackle this under this as well, and so on. So basically, there's gonna be some other pathways. There's gonna be Pdf to deal with infrared, I mean, initial state radiation deal with, and so on, but no show stoppers, as far as I can think of
WH11NE- Sunrise: any other.
WH11NE- Sunrise: I'm happy to also like talk to people here people on zoom, but like
WH11NE- Sunrise: what the next steps would look like, how do we? How does this get implemented and generated? And so on.
WH11NE- Sunrise: Probably none of us are going to be doing it. We'll be eagerly awaiting it, because it will, as you said, save us a lot of money, real money. It costs a lot of money to run these simulations, and it is in the tens of millions.
WH11NE- Sunrise: I think people appreciate how much we spend on simulation.
WH11NE- Sunrise: It's expensive.
WH11NE- Sunrise: Yeah. And and just to give some context, although all of this is talked about in the event generator stage
WH11NE- Sunrise: the implications about simulation as well. Just because if you don't unmute it, then everything.
Saptaparna Bhattacharya: Sorry if I may add something quickly, since you asked this question about how to get this integrated into event generator packages. So I'm in this weird phase when I'm transitioning to Atlas. But I think what you should do is reach out to the event. Generator conveners in Cms and give a talk in the Generator group meeting. And the way we've done this so far is that there's always a dedicated person.
Saptaparna Bhattacharya: So we have very few people in our team. And typically one of the conveners level 3 conveners kind of decides to allocate some time, and then they get. Epr. These authorship points for this kind of work. So you know, people usually, you know, one or 2 people will dedicate some time, do a feasibility study, and then we see how much time it'll take to actually put this in production workflows.
Saptaparna Bhattacharya: Of course we will need examples of proton proton collisions. So that would be a prerequisite, I would say, but I feel like at this stage, the Event Generator group. I think people will welcome a talk in the Generator group meeting.
WH11NE- Sunrise: That sounds good.
Saptaparna Bhattacharya: And I can send you the details, the email ids and things like that.
WH11NE- Sunrise: Thank you.
Saptaparna Bhattacharya: Appreciate that.
Saptaparna Bhattacharya: Yeah, no problem.