text:
# Search for a massive resonance decaying to a pair of Higgs bosons in the four b quark final state in proton–proton collisions at √s 13 TeV

CMS Collaboration; Sirunyan, A.M.; Tumasyan, A.; Adam, W.; Ambrogi, F.; Asilar, E.; Bergauer, T.; Brandstetter, J.; Brondolin, E.; Dragicevic, M.; Erö, J.; Flechl, M.; Friedl, M.; Frühwirth, R.; Ghete, V.M.; Grossmann, J.; Hrubec, J.; Jeitler, M.; König, A.; Krammer, N.; Krätschmer, I.; ... mehr

Abstract:
A search for a massive resonance decaying into a pair of standard model Higgs bosons, in a final state consisting of two b quark–antiquark pairs, is performed. A data sample of proton–proton collisions at a centre-of-mass energy of 13 TeV is used, collected by the CMS experiment at the CERN LHC in 2016, and corresponding to an integrated luminosity of 35.9
fb⁻¹. The Higgs bosons are highly Lorentz-boosted and are each reconstructed as a single large-area jet. The signal is characterized by a peak in the dijet invariant mass distribution, above a background from the standard model multijet production. The observations are consistent with the background expectations, and are interpreted as upper limits on the products of the s-channel production cross sections and branching fractions of narrow bulk gravitons and radions in warped extra-dimensional models. The limits range from 126 to 1.4 fb at 95% confidence level for resonances with masses between 750 and 3000 GeV, and are the most stringent to date, over the explored mass range.

 Zugehörige Institution(en) am KIT Institut für Experimentelle Kernphysik (IEKP) Publikationstyp Zeitschriftenaufsatz Jahr 2018 Sprache Englisch Identifikator ISSN: 0370-2693 URN: urn:nbn:de:swb:90-833512 KITopen ID: 1000083351 Erschienen in Physics letters / B Band 781 Seiten 244–269 Bemerkung zur Veröffentlichung Gefördert durch SCOAP3 Schlagworte CMS; Physics; Extradimensions; Graviton; Radion; di-Higgs boson resonance
KIT – Die Forschungsuniversität in der Helmholtz-Gemeinschaft KITopen Landing Page


text:
# fimath

Set fixed-point math settings

## Description

example

F = fimath creates a fimath object with the default fimath property settings.

example

F = fimath(Name,Value) specifies the properties of a fimath object by using one or more name-value pair arguments. All properties not specified in the constructor use default values.

## Examples

collapse all

This example shows how to create a fimath object with the default property settings.

F = fimath
F =
RoundingMethod: Nearest
OverflowAction: Saturate
ProductMode: FullPrecision
SumMode: FullPrecision

Set the properties of a fimath object at the time of object creation by using name-value pairs. For example, set the overflow action to saturate and the rounding method to convergent.

F = fimath('OverflowAction','Saturate','RoundingMethod','Convergent')
F =
RoundingMethod: Convergent
OverflowAction: Saturate
ProductMode: FullPrecision
SumMode: FullPrecision

## Input Arguments

collapse all

### Name-Value Arguments

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Before R2021a, use commas to separate each name and value, and enclose Name in quotes.

Example: F = fimath('OverflowAction','Saturate','RoundingMethod','Floor')

Whether both operands are cast to the sum data type before addition, specified as a numeric or logical 1 (true) or 0 (false).

Note

This property is hidden when the SumMode is set to FullPrecision.

Example: F = fimath('CastBeforeSum',true)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

Maximum allowable word length for the product data type, specified as a positive integer.

Example: F = fimath('MaxProductWordLength',16)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Maximum allowable word length for the sum data type, specified as a positive integer.

Example: F = fimath('MaxSumWordLength',16)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Action to take on overflow, specified as one of these values:

• 'Saturate' – Saturate to the maximum or minimum value of the fixed-point range on overflow.

• 'Wrap' – Wrap on overflow. This mode is also known as two's complement overflow.

Example: F = fimath('OverflowAction','Wrap')

Data Types: char

Bias of the product data type, specified as a floating-point number.

Example: F = fimath('ProductBias',1)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Fixed exponent of the product data type, specified as a nonzero integer.

Note

The ProductFractionLength is the negative of the ProductFixedExponent. Changing one property changes the other.

Example: F = fimath('ProductFixedExponent',-20)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Fraction length, in bits, of the product data type, specified as a nonzero integer.

Note

The ProductFractionLength is the negative of the ProductFixedExponent. Changing one property changes the other.

Example: F = fimath('ProductFractionLength',20)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

How the product data type is determined, specified as one of these values:

• 'FullPrecision' – The full precision of the result is kept.

• 'KeepLSB' – Keep the least significant bits. Specify the product word length. The fraction length is set to maintain the least significant bits of the product.

• 'KeepMSB' – Keep the most significant bits. Specify the product word length. The fraction length is set to maintain the most significant bits of the product.

• 'SpecifyPrecision' – Specify the word and fraction lengths or slope and bias of the product.

Example: F = fimath('ProductMode','KeepLSB')

Data Types: char

Slope of the product data type, specified as a finite, positive floating-point number.

Note

$ProductSlope=ProductSlopeAdjustmentFactor×{2}^{ProductFixedExponent}$

Changing one of these properties affects the others.

Example: F = fimath('ProductSlope',9.3132e-10)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Slope adjustment factor of the product data type, specified as a floating-point number greater than or equal to 1 and less than 2.

Note

$ProductSlope=ProductSlopeAdjustmentFactor×{2}^{ProductFixedExponent}$

Changing one of these properties affects the others.

Example: F = fimath('ProductSlopeAdjustmentFactor',1)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Word length, in bits, of the product data type, specified as a positive integer.

Example: F = fimath('ProductWordLength',64)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Rounding method to use, specified as one of these values:

• 'Nearest' – Round toward nearest. Ties round toward positive infinity.

• 'Ceiling' – Round toward positive infinity.

• 'Convergent' – Round toward nearest. Ties round to the nearest even stored integer (least biased).

• 'Zero' – Round toward zero.

• 'Floor' – Round toward negative infinity.

• 'Round' – Round toward nearest. Ties round toward negative infinity for negative numbers, and toward positive infinity for positive numbers.

Example: F = fimath('RoundingMethod','Convergent')

Data Types: char

Bias of the sum data type, specified as a floating-point number.

Example: F = fimath('SumBias',0)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Fixed exponent of the sum data type, specified as a nonzero integer.

Note

The SumFractionLength is the negative of the SumFixedExponent. Changing one property changes the other.

Example: F = fimath('SumFixedExponent',-20)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Fraction length, in bits, of the sum data type, specified as a nonzero integer.

Note

The SumFractionLength is the negative of the SumFixedExponent. Changing one property changes the other.

Example: F = fimath('SumFractionLength',20)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

How the sum data type is determined, specified as one of these values:

• 'FullPrecision' – The full precision of the result is kept.

• 'KeepLSB' – Keep least significant bits. Specify the sum data type word length. The fraction length is set to maintain the least significant bits of the sum.

• 'KeepMSB' – Keep most significant bits. Specify the sum data type word length. The fraction length is set to maintain the most significant bits of the sum and no more fractional bits than necessary.

• 'SpecifyPrecision' – Specify the word and fraction lengths or slope and bias of the sum data type.

Example: F = fimath('SumMode','KeepLSB')

Data Types: char

Slope of the sum data type, specified as a floating-point number.

Note

$SumSlope=SumSlopeAdjustmentFactor×{2}^{SumFixedExponent}$

Changing one of these properties affects the others.

Example: F = fimath('SumSlope',9.3132e-10)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Slope adjustment factor of the sum data type, specified as a floating-point number greater than or equal to 1 and less than 2.

Note

$SumSlope=SumSlopeAdjustmentFactor×{2}^{SumFixedExponent}$

Changing one of these properties affects the others.

Example: F = fimath('SumSlopeAdjustmentFactor',1)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Word length, in bits, of the sum data type, specified as a positive integer.

Example: F = fimath('SumWordLength',64)

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

## Version History

Introduced before R2006a

expand all

format: plain


text:
# Show that $p$ divide $\binom{p}{k}$ for all $0<k<p$ and $p$ prime. [duplicate]

I have to show that $(a+b)^p=a^p+b^p$ in $\mathbb Z/p\mathbb Z$ for $p$ prime. In other word that $p$ divide $\binom{p}{k}$ for $0<k<p$. I tryied many thing but impossible to conclude algebraically. But can I do like this: $$\binom{p}{k}=\frac{p!}{k!(p-k)!}=\frac{(p-k+1)(p-k+2)... (p-1)p}{k!}\in\mathbb N$$ Since $p$ is prime, not in $1\leq i\leq k$ divide $p$ and thus $\frac{(p-k+1)...(p-1)}{k!}\in\mathbb N$ therefore $$\frac{(p-k+1)(p-k+2)... (p-1)p}{k!}=mp$$ for $m\in\mathbb N$ and thus $p$ divide $\binom{p}{k}$.

Do you think it work ? The problem is i'm not sure that (if $m<n$) $$\frac{a_1\cdot ...\cdot a_n}{b_1\cdot ...\cdot b_m}\in\mathbb N\implies \forall a_i, \exists b_j: b_j\mid a_i.$$

What do you think ?

• Here is another, Proving prime $p$ divides $p\choose k$ for $k\in\{1,\dots,p−1\}$. – user249332 Dec 20 '15 at 20:58
• Ok thank you. By the way, do you have a link of the proof that $\frac{n!}{k!(n-k)!}$ is really an integer ? I also have difficulties to prove it. And more generally that if $n-p> k$ that $\frac{n(n-1)...(n-p)}{k!}$ is also an integer ? – MSE Dec 20 '15 at 21:09
• By definition ${n\choose k}$ is an integer, it's the number of subset of $\{1,\ldots,n\}$ of cardinality $k$. From there, if you manage to proove that ${n\choose k}=\frac{n!}{k!(n-k)!}$, you are done. – C. Falcon Dec 20 '15 at 21:17

Somehow you have to use that $p$ is prime. Either you use the decomposition into prime factors ( $p$ appears in the numerator but not in the denominator, so it can't disappear) or, more formally:
Let $N = \binom{p}{k} = \frac{p!}{(p-k)! k!}$. Then $(p-k)! k! \cdot N = p!$ clearly divisible by $p$. However, $p \not \mid (p-k)! k!$, since it does not divide any number from $1$ to $p-1$ so neither their product ( here we use the fact that $p$ is prime). Now, if since $p$ does not divide $(p-k)! k!$ then the gcd $(p, (p-k)! k!) = 1$ (again we use that $p$ is prime), so $u p + v(p-k)! k! = 1$. Multiply this by $N$ and get $$u pN + v(p-k)! k!N = N$$ The first term is clearly divisible by $p$, and so is the second, being $p!$.
Thus $p \mid N$.
Obs: In general, if $p$ divides $b \cdot N$ and $(p,b)=1$ then $p$ divides $N$. Or : if $N=\frac{a}{b}$ integer, $p$ divides $a$ and $(p,b) = 1$ then $p$ divides $N$.


text:
Poster
Discovering Context Effects from Raw Choice Data
Arjun Seshadri · Alexander Peysakhovich · Johan Ugander

Thu Jun 13th 06:30 -- 09:00 PM @ Pacific Ballroom #234

Many applications in preference learning assume that decisions come from the maximization of a stable utility function. Yet a large experimental literature shows that individual choices and judgements can be affected by irrelevant'' aspects of the context in which they are made. An important class of such contexts is the composition of the choice set. In this work, our goal is to discover such choice set effects from raw choice data. We introduce an extension of the Multinomial Logit (MNL) model, called the context dependent random utility model (CDM), which allows for a particular class of choice set effects. We show that the CDM can be thought of as a second-order approximation to a general choice system, can be inferred optimally using maximum likelihood and, importantly, is easily interpretable. We apply the CDM to both real and simulated choice data to perform principled exploratory analyses for the presence of choice set effects.


text:
# Two particles start moving from the same point in a straight line. The first moves with constant velocity v and second moves with constant acceleration a. During the time that elapses before the second catches the first, the greatest distance between the particle is

$(a)\;\frac{v^2}{a}\quad (b)\;\frac{v^2}{2a} \quad (c)\;\frac{2v^2}{a} \quad (d)\frac{v^2}{4a}$

Let x be distance between particles after t seconds Then
I particle $x_1=vt$
II particle $x_2=\large\frac{1}{2}$$at^2 x=x_1-x_2 \quad=vt-\large\frac{1}{2}$$at^2$-----(1)
For x maximum
$\large\frac{dx}{dt}$$=0=>v-at=0$
$=>t=\large\frac{v}{a}$
Substituting value of t in (1)
$x=v \bigg(\large\frac{v}{a}\bigg)-\large\frac{1}{2} a \bigg(\frac{v}{a}\bigg)^2$
$\quad=\large\frac{v^2}{2a}$
Hence b is the correct answer

answered Jun 26, 2013 by
edited Jan 25, 2014 by meena.p


text:
# Knowledge Bank

## University Libraries and the Office of the Chief Information Officer

The Knowledge Bank is scheduled for regular maintenance on Sunday, April 20th, 8:00 am to 12:00 pm EDT. During this time users will not be able to register, login, or submit content.

# THE MANY-LINE SPECTRA OF OH AND DO NEAR 1850 {\AA}.

Please use this identifier to cite or link to this item: http://hdl.handle.net/1811/12552

Files Size Format View
1991-TG-02.jpg 131.4Kb JPEG image

 Title: THE MANY-LINE SPECTRA OF OH AND DO NEAR 1850 {\AA}. Creators: Coxon, John A.; Holland, F.; Huber, K. P. Issue Date: 1991 Abstract: We have observed the complex VUV spectra of OH and OD near 1850 {\AA}$^{1}$ in emission from a corona discharge through supersonically expanding mixtures of $H_{2}O$ or $D_{2}O$ with He or Ar. The emission is particularly strong in the presence of He; under these conditions the spectrum produced with $D_{2}O$ completely changes in character and reveals a regular lower-state progression of redsnaded bands. They arise in transitions from a single $2_{\Pi_{1}}$ vibronic level near $C^{2}\sum^{+}$ to v""=13... 15 of the $X^{2}\Pi_{i}$ ground state of DD, extencing the observations of the ground state potential to within 2350 $cm^{-1}$ of the $^{3}P+^{2}S$ dissociation limit and providing the first experimental evidence for an excited state of the hycroxyl radical. In all probability the spectra represent the strongest of several $2_\Pi-2_\Pi$ transitions predicted by van Dishoeck $et al.,^{2}$ the radiative behavior of the loosely bound upper state being strongly influenced by overlapping Rydberg states of the same symmetry and by the unstable $2_\Pi$ state from $^{1}D+^{2}S$ dissociation products. URI: http://hdl.handle.net/1811/12552 Other Identifiers: 1991-TG-2


text:
## Calculus (3rd Edition)

Published by W. H. Freeman

# Chapter 8 - Techniques of Integration - 8.2 Trigonometric Integrals - Exercises - Page 403: 55

#### Answer

$$\ln 2$$

#### Work Step by Step

\begin{align*} \int_{0}^{\pi / 3} \tan x d x&=\ln | \sec x| \bigg|_{0}^{\pi / 3}\\ &=\ln 2-\ln 1\\ &=\ln 2 \end{align*}

After you claim an answer you’ll have 24 hours to send in a draft. An editor will review the submission and either publish your submission or provide feedback.


text:
## Elementary and Intermediate Algebra: Concepts & Applications (6th Edition)

$|x|$
Using $\sqrt{x^2}=|x|$, the given expression, $\sqrt[6]{x^6} ,$ simplifies to \begin{array}{l} \sqrt[6]{(x)^6} \\\\= |x| .\end{array} We put the variable in absolute value bars since it is being raised to an odd power.


text:
Regression diagmostics: PROC REG versus PROC GLM

noetsi

No cake for spunky
PROC GLM has many advantages over proc reg such as a case statement. But SAS has chosen not to include many of the diagnostics in proc glm that are in proc reg. The logical solution is to run the model in Proc Glm, than run the same model with diagnostics in proc reg.

The problem with this is, potentially, that you are treating dummy variables differently in the two, through the CLASS statement. Will this influence the diagnostics, that test for things like unequal error variance, non-linearity, multicolinearity etc?

I am concerned I will run the diagnostics in PROC REG and they will be ok, but not be ok in PROC GLM (really they won't be substantively correct at all) because of issues such as how dummy variables are treated differently in the two procs.

While I am at it, the RAMSEY RESET test is offered as a test for non-linearity. It is done as far as I know only in PROC AUTOREG and my data is not time series. Does anyone know if this can be used in another form of regression? I have found no examples of this on line.

Last edited:

Stu

New Member
PROC AUTOREG is the only one. The good news is, PROC AUTOREG can act just like PROC REG, so you can safely use it for non-timeseries data In a nutshell, PROC AUTOREG is just like any other of the regression procedures with support for handling autoregression. If you compare the parameter estimates between PROC REG and PROC TIMESERIES, they'll be the same. Just ignore the ACF/PACF plots

Code:
proc autoreg data=sashelp.cars;
model MPG_City = EngineSize Cylinders Horsepower / reset;
run;

proc reg data=sashelp.cars;
model MPG_City = EngineSize Cylinders Horsepower;
run;
Interesting note, PROC ARIMA can act like PROC REG, too!

Code:
proc arima data=sashelp.cars;
identify var=MPG_City crosscorr=(EngineSize Cylinders Horsepower);
estimate input=(EngineSize Cylinders Horsepower);
run;

Last edited:

hlsmith

Less is more. Stay pure. Stay poor.
Hey, I think I remember looking into RESET. So it can be used to test a linear relationship in regression. Stu, you are saying that I can put my model terms in proc autoreg and run it to get at using the RESET? Does PROC AUTOREG have a CLASS option?

Does AUTOREG tolerate categorical or other dependent variables?

Stu

New Member
Hey, I think I remember looking into RESET. So it can be used to test a linear relationship in regression. Stu, you are saying that I can put my model terms in proc autoreg and run it to get at using the RESET? Does PROC AUTOREG have a CLASS option?

Does AUTOREG tolerate categorical or other dependent variables?
Correct. Think of AUTOREG as PROC GLM with optional ARMA factors. It does support the CLASS statement, but there's a caveat.

Code:
proc autoreg data=sashelp.cars;
class drivetrain;
model MPG_City = drivetrain  ;
run;
...it's experimental.

Code:
WARNING: The CLASS statement is experimental in this release.
Which means you'll get this warning:

NOTE: Model is not full rank. OLS estimates for the parameters are not unique. Some statistics will be misleading. A reported DF of 0 or B means that the estimate is biased. The parameter estimate for the following LHS variable is set to 0, since this variable is a linear combination of other RHS variables as shown.

DriveTrain Front = Intercept - DriveTrain All - DriveTrain Rear

You'll think, "DUH. I know this already! I just need a baseline" For now with PROC AUTOREG, it appears that you'll need to manually need to set a baseline variable by setting the desired base to missing.

Code:
data cars;
set sashelp.cars;
if(upcase(drivetrain) = 'FRONT') then call missing(drivetrain);
run;

proc autoreg data=cars;
class drivetrain;
model MPG_City = drivetrain  ;
run;
The good news is, SAS is smart enough to tell you that there's a problem with the model, and it won't just give you incorrect estimates without telling you that they're wrong. That's the only bug I can see with the class statement in AUTOREG.

If all else fails, you can always use the tried-and-true method of dummy variables to get the same estimates:

Code:
data cars;
set sashelp.cars;
array dt[*] rear all;

do i = 1 to 2;
dt[i] = (upcase(drivetrain) = upcase(vname(dt[i]) ) );
end;

drop i;
run;

proc autoreg data=cars;
model MPG_City = rear all;
run;

hlsmith

Less is more. Stay pure. Stay poor.
PROC AUTOREG is the only one. The good news is, PROC AUTOREG can act just like PROC REG, so you can safely use it for non-timeseries data In a nutshell, PROC AUTOREG is just like any other of the regression procedures with support for handling autoregression. If you compare the parameter estimates between PROC REG and PROC TIMESERIES, they'll be the same. Just ignore the ACF/PACF plots

Code:
proc autoreg data=sashelp.cars;
model MPG_City = EngineSize Cylinders Horsepower / ramsey;
run;

proc reg data=sashelp.cars;
model MPG_City = EngineSize Cylinders Horsepower;
run;

STU,
Thanks for your time. So in the code above you meant "/ RESET" not "/ Ramsey". When I run the code you posted it kicks out the Ramsey's RESET Test. Power 2-4 represent continuous variables raised to **2nd , **3rd, or **4th power for all variables in the model? And since the F-test is significant this means the model with main effects is mis-specified, AKA not as good as the Power-based models. Is this all correct? Sorry for not looking this up myself, I am just trying to get the answers straight from Cary if I can.

Stu

New Member
STU,
Thanks for your time. So in the code above you meant "/ RESET" not "/ Ramsey". When I run the code you posted it kicks out the Ramsey's RESET Test. Power 2-4 represent continuous variables raised to **2nd , **3rd, or **4th power for all variables in the model? And since the F-test is significant this means the model with main effects is mis-specified, AKA not as good as the Power-based models. Is this all correct? Sorry for not looking this up myself, I am just trying to get the answers straight from Cary if I can.
Correct, Power 2-4 does represent the continuous variables raised to the 2nd, 3rd, and 4th power. Rejecting the null hypothesis suggests that it is not as good as a power-based model.

As an exploratory exercise, we can plot different dependent variables against mpg_city to see where the non-linearity may be. We end up finding that engine size and city MPG appear to be non-linearly related.

Code:
proc sgplot data=sashelp.cars;
scatter x=mpg_city y=enginesize;
run;

Our model improves by removing the insignificant factor, Cylinders, and adding a squared term for EngineSize (though with this, you'd be better off trying a log or inverse transform on y, but for example's sake let's roll with it).

Code:
proc glm data=sashelp.cars;
model mpg_city = enginesize enginesize*enginesize horsepower;
run;

Last edited:


text:
# How does TLC functions work under the hood?

62 views

### Victor Miraldo

Aug 13, 2021, 9:12:03 AMAug 13
to tlaplus
Hello all,

I have some TLA+ spec that makes heavy use of functions and TLC takes a long time (minutes) to check that even the simplest property, i.e., [](FALSE), doesn't hold. This made me question how TLC handles functions, but I can't find information elsewhere.

When I write [ x \in TypeX |-> f(x) ], is TLC generating all elements in TypeX then computing their image under f or does it wait until its called with an argument m to compute its image under f?

Is there a way to make TLA+ lazy, preventing it from ever generating TypeX in its entirety? Unfortunately we have some very large TypeXs in our generated code, such as the type of functions that receive lists and return lists.

Unfortunately, I can't use operators here because these need to be passed as arguments to mutually recursive operators.

Thanks,
Victor

### Markus Kuppe

Aug 13, 2021, 6:25:35 PMAug 13
Hi Victor,

I'd suggest to debug TLC [1] (look for tlc2.value.impl.FcnRcdValue), but
the Toolbox's profiler [1] might be good enough to find out what is

Btw. for "very large sets", TLC usually errors with:

Evaluating assumption line ... module ... failed.
Attempted to construct a set with too many elements (>1000000).

Since doesn't error out on you, you should ensure you're not chasing a
red herring.

M.

[1] https://github.com/tlaplus/tlaplus/tree/master/general/ide
[2] https://tla.msr-inria.inria.fr/tlatoolbox/doc/model/profiling.html
[3] https://youtu.be/6oMQYHogQek

### Victor Miraldo

Aug 16, 2021, 8:22:59 AMAug 16
to tlaplus
Hello Markus,

Thank you for the pointers! I'll follow through and try to understand what is going on.

Cheers
Victor

### Victor Miraldo

Aug 25, 2021, 6:01:31 AMAug 25
to tlaplus
After some back and forth between different encodings, I got to learn a little more TLA+ and would like to document my findings here.

> When I write [ x \in TypeX |-> f(x) ], is TLC generating all elements in TypeX then computing their image under f or does it wait until its called with an argument m to compute its image under f?

Yes, TLA+ does enumerate the domain of functions before computing the point in the image. This incurred a ridiculous overhead. We've seen a speedup from 4m46s to 12s to check a silly invariant. :)

As a good rule of thumb, avoiding TLA+ functions as much as possible is good. Doing that for generated code might involve working around the mutually recursive higher order operators in TLA+ problem.
Turns out that as long as your recursive calls do not change the higher-order operator being passed around, nested LET expressions work well:

entrypoint(Op(_,_),x,...) ==
LET RECURSIVE f1(...)
RECURSIVE f2(...)
f1(...) == ... Op(f2(....), ...)
f2(...) == ... Op(f1(...), ...)
IN f1(a,b,c,...)

I guess we're yet another person using the "feature" of recursive higher order operators in: https://github.com/tlaplus/tlaplus/issues/57  :)

Cheers,
Victor


text:
# How does one find the normalization constant for a Gaussian representation of lognormal data?

EDIT: I have optimized values of sigma and mu for a lognormal distribution. I want to represent that data as a Gaussian curve, for which the x-axis will be logarithmic. How do I find the normalization constant for my Gaussian and for my lognormal distribution? For the Gaussian distribution (pictured below), I used cnorm = 1 / ( sigma * (2 * pi)^.5 ).

TL;DR:

I am trying to perfect a routine in python on a random-number-generated data sample so that I can apply the "perfected" routine to my actual dataset. I was able to make the routine work smoothly for a Gaussian distribution but not for a lognormal distribution.

The code uses an initial guess value of mu and sigma to calculate an initial Chi-Square value. The parameters (mu and sigma) that produce the minimized Chi-Square are optimized. I was able to optimize these parameters for a lognormal distribution and a Gaussian distribution. By converting the x-axis of a lognormal distribution to a log(x)-axis, the lognormal distribution should look more Gaussian. However, I cannot figure out how to find the proper normalization constant for this new Gaussian representation of the data.

I have 2 sample plots. The one on the left (in the picture) is for the case of a random-Gaussian-number-generator; this one works properly. The one on the right (in the picture) is from running the entire code. The histogram data is normalized but the normalization constant for my lognormal Gaussian fit is clearly wrong. How can I find the proper normalization constant when displaying a normal representation of a lognormal distribution?

That's the TL;DR. The full problem and code is explained in-depth below.

""" IMPORTS """

## GENERATE DATA SAMPLE (( TEST CASE ))
from numpy.random import lognormal as randomlgn
## MATH SYNTAX
from math import exp
from math import log
from math import pi
## INTEGRATATION ROUTINE
## OPTIMIZATION ROUTINES
from scipy.optimize import minimize
from scipy.optimize import basinhopping
## CALCULATE CHISQ ++ PROBABILITY
from scipy.stats import chisquare
## NORMALIZE DISTRIBUTION
from scipy.stats import norm
## PLOT
import numpy as np
import matplotlib.pyplot as plt

""" GENERATE DATA """

mu_true, sigma_true = 48, 7
randlog = randomlgn( mu_true , sigma_true , size = 25000)
datatrue = sorted(randlog)
data = [log(val) for val in datatrue]

""" DEFINE x-range """

small = 1 # min(data) ## smallest value in data
big = 100 # max(data) ## largest value in data
domain = np.linspace(small,big,10000) ## 10000 steps

I then defined functions to help me count the number of observations per bin and to help me tick the midpoints of the bins along the x-axis.

""" DEFINE BIN FUNCTIONS ++ ORGANIZE BINS """

numbins = 40 ## number of bins

def binbounder( small , big , numbins ):
## generates list of bound bins
## used for histogram ++ bincount
binwide = ( big - small ) / numbins
binleft = []
for index in range( numbins ):
binleft.append( small + index * binwide )
binbound = [val for val in binleft]
binbound.append( big )
return binbound

def countperbin( binbound , values ):
## calculates multiplicity of observed values per bin
values = sorted( values )
bincount = []
for jndex in range( len( binbound ) ):
if jndex != len( binbound ) - 1:
summ = 0
for val in values:
if val > binbound[ jndex ] and val <= binbound[ jndex + 1 ]:
summ += 1
bincount.append( summ )
if jndex == len( binbound ) - 1:
pass
return bincount

binborders = binbounder( small , big , numbins )
obsperbin = countperbin( binborders , data )
numobs  = sum( obsperbin )
maxbin = max(obsperbin)

To calculate the expectation values per bin, one must find the area under the curve, per bin, from x1 = left bin edge to x2 = right bin edge. The area under the curve is the same as the integral of the distribution function from the left bin edge to the right bin edge. Luckily, the bin edges are defined above to simplify the integrations per bin.

""" DEFINE DISTRIBUTION ++ EXPECTATION VALUE CALCULATOR """

def distribution( x , mu , sigma ): ## LOGNORMAL
sigma = abs(sigma)
cnorm = 1 / ( sigma * ( 2*pi )**(1/2) )
return cnorm / x * exp( (-1) * ( log(x) - mu )**2 / ( 2 * (sigma **2) ) )

def expectperbin( args ):
## args[0] = mu
## args[1] = sigma
## calculates expectation values per bin
## expectation value of single bin is equal to area under Gaussian
## from left bin-edge to right bin-edge multiplied by the sample size
xpct = []
for i in range(len(binborders)-1): # ith i does not exist for rightmost boundary
xpct.append( quad( distribution , binborders[ i ] , binborders[ i + 1 ],
args = ( args[0] , args[1] ))[0] * numobs )
return xpct

Using the expected values per bin and the observed multiplicities per bin, one can now calculate the Chi-Squared value of the fit. The goal is to minimize Chi-Squared. Two minimization methods are posted, though "Basin Hopping" takes much longer and is unnecessary. The minimization methods require an initial guess of Chi-Squared, which in turn depends on an initial guess of mu and sigma. The code should spit out the optimized parameters (mu and sigma) that yield the minimized value of Chi-Squared.

""" DEFINE CHI SQUARE ++ MINIMIZATION ROUTINE """

def chisq( args ):
## first subscript [0] gives chi-squared value, [1] gives 0 = p-value = 1
return chisquare( obsperbin , expectperbin( args ))[0]

def miniz( chisq , parameterguess, ):
## MINIMIZATION ROUTINES    --    https://docs.scipy.org/doc/scipy-0.14.0/reference/optimize.html
##      via SCIPY

""" ROUTINE 1:    BASIN HOP """
# globmin = basinhopping( chisq , parameterguess , niter = 200 )
# while globmin.fun <= 0:
#     ## self-correcting mechanism if ChiSq is negative
#     ## GLOBAL MIN ==> DOES NOT WORK WITH 'SUCCESS TEST' of SCIPY MODULE
#
#     try:
#         globmin = basinhopping( chisq , parameterguess , niter = 200 )
#         print("ERROR:   BASINHOP LOOPING AGAIN")
#         break
#     except globmin.fun > 0:
#         print("TA DAA")
#         break
#
# return globmin

""" ROUTINE 2:    MINIMIZE (SCALAR MULTIVARIABLE FUNCTION) """
globmin = minimize( chisq , parameterguess)
while globmin.success == False:
## self-correcting mechanism if 'success test' fails

try:
globmin = minimize( chisq , parameterguess)
print("ERROR:   MINIMIZE LOOPING AGAIN")
break
except globmin.success == True:
print("TA DAA")
break

return globmin

""" PICK INITIAL PARAMETERS TO PICK GUESS VALUE """

## INITIAL GUESS OF mu ++ sigma (ex:    100, 20)
## TRUE VALUES: mu_true = 48, sigma_true = 7
## PICK WRONG GUESSES TO TEST STRENGTH OF MINIMIZATION METHOD (limits = ??)
initial_mu, initial_sigma = 100,20

## INITIAL GUESS OF CHI SQ MINIMUM (DEPENDS ON GUESS VALUES OF mu ++ sigma)
chisqguess = chisquare( obsperbin , expectperbin( [initial_mu , initial_sigma] ))[0]

""" OPTIMIZATION """

## CALCULATION
res = miniz( chisq, [initial_mu , initial_sigma] ) ## FULL OPTIMIZED RESULT
mulog = res.x[0] ## OPTIMIZED MU FOR LGN DISTRIBUTION
sigmalog = res.x[1] ## OPTIMIZED SIGMA FOR LGN DISTRIBUTION

The optimized values of mu and sigma must be recalibrated from the lognormal distribution to fit the normal distribution.

## SOURCE >> https://www.mathworks.com/help/stats/lognstat.html
mu_opt = exp( mulog + (sigmalog**2 /2) )  ## OPTIMIZED MU
sigma_opt = ( exp(2 * mulog + sigmalog**2) * (exp( sigmalog**2 ) - 1) )**(1/2) ## OPTIMIZED SIGMA
cnorm = 1 / ( sigma_opt * ( 2*pi )**(1/2) ) ## OPTIMIZED NORMALIZATION CONSTANT

chisqstats = chisquare( obsperbin, expectperbin( [mu_opt , sigma_opt] ) ) ## RECALCULATE CHISQ via (mu_opt , sigma_opt)
chisqmin = chisqstats[0]
pval = chisqstats[1]

numconstraints = 3 ## mu, sigma, numobs
dof = numbins - numconstraints ## degrees of freedom

## CHECK RESULTS
print("""""")
chisqmin = chisquare( obsperbin, expectperbin( [mu_opt , sigma_opt] ) )[0]
chisqred = chisqmin/dof

Below is a bunch of print statements that made/make debugging easier. Everything should be easy to read from the terminal window.

print("                 CHI SQUARE MINIMIZATION")
print("")
print("OPTIMIZED PARAMETERS:")
print("     guess values          --      mu =", initial_mu,",","sigma =", initial_sigma)
print("     actual values         --      mu =", mu_true,",","sigma =", sigma_true)
print("     optimized values      --      mu =", mu_opt,",","sigma =", sigma_opt)
print("")
print("CHISQ")
print("     guess value           --      chisq =", chisqguess)
print("     minimized value       --      chisq =", chisqmin)
print("     probability           --      p-value =", pval)
print("")
print("     number of bins        =", numbins)
print("     number of constraints =", numconstraints, "   ","(mu, sigma, number of observed values)")
print("     degrees of freedom    =", dof)
print("     reduced value         --      chisq_red =", chisqred)
# print("     probability         --      p-value =", predval)

print("")
print("MINIMIZATION SPECS")
print("""
""")

I then want to plot a histogram of the data and my fit to the data that minimized Chi-Squared.

""" DEFINE FITTED DISTRIBUTIONS TO PLOT """

binwide = (big - small) / numbins ## binwidth
numdata = len(data) ## number of observations
cscale = binwide * numdata * cnorm ## rescale from normalization

def distribfitted(x):
## PLOT DISTRIBUTION (( NORMALIZED ))
cnorm = 1 / ( sigma_opt * ( 2*pi )**(1/2) )
return [(( cnorm * exp( (-1) * (x[index] - mu_opt)**2 / ( 2 * (sigma_opt **2) ) ) )) for index in range(len(x))]

def distribscaled(x):
## PLOT DISTRIBUTION (( NOT NORMALIZED ))
cnorm = 1 / ( sigma_opt * ( 2*pi )**(1/2) )
cscale = binwide * numdata * cnorm
return [(( cscale * exp( (-1) * (x[index] - mu_opt)**2 / ( 2 * (sigma_opt **2) ) ) )) for index in range(len(x))]

""" PLOT PROBABILITY HISTOGRAM ++ FITTED OVERLAY """

## >> NORMALIZED

## DISPLAY VALUES IN LEGEND
plt.plot(np.NaN, np.NaN, '-', color='none', label = '$\mu_{opt}=%.3f$, $\mu=%.3f$' %(mu_opt,mu_true))
plt.plot(np.NaN, np.NaN, '-', color='none', label = '$\sigma_{opt}=%.3f$, $\sigma=%.3f$' %(sigma_opt,sigma_true))
plt.plot(np.NaN, np.NaN, '-', color='none', label = '$\chi^2_{opt}=%.3f$' %chisqmin)

## PLOT HISTOGRAM ++ OVERLAY FIT
plt.hist(data, bins = binborders, alpha = 0.25, label = 'Binned Data', normed = True)
plt.plot(domain,distribfitted(domain),'r-',label = 'Gaussian Fit')

## FORMATTING
plt.title('Histogram: Normalized Probability Distribution of Data with Fitted Overlay') ## put equation f(x)=N*exp(-...)
plt.ylabel('Probabilities')
plt.xlabel('ln (x)')
plt.legend(loc='best', fontsize = 'medium')
plt.tight_layout()
plt.grid(True)

plt.show()

• While there is a subtle difference in the way your data fits, I'm not sure why you want to need better fitting data or why you are trying to use the $\chi^2$ to create data when there are much simpler and straightforward ways to create a perfect representation of the data. For example, using the percentile point function and inverse distributions as described in this question yield perfect results with much less hassle: stats.stackexchange.com/questions/259654/… – Tavrock Mar 6 '17 at 6:51
• I am trying to replicate the plots in this research paper. This particular one is the second plot (on page 2). The researchers calculated Chi Square for their data fit. – MPath Mar 6 '17 at 6:56
• Also to clarify, I am not familiar at all with percentile point functions or inverse distributions. – MPath Mar 6 '17 at 21:58
• Inverse distributions allow you to create the pdf from the percent of the distribution and the distribution parameters. Percentile point functions allow you to create a uniform percentile that works well with inverse distributions. I'm not sure what the process is for Python to use inverse distributions, but I am pretty sure they have them. Also, looking back at the paper referenced, it seems that they went with an inverse distribution that was "good enough" for their data. As a result, your results may be as good as theirs were. – Tavrock Mar 6 '17 at 22:36
• I don't understand the method just yet. But it appears that pdf (via scipy module for python) uses this to calculate the curve that best approximates the probability density function. In any case, I realized that my mu and sigma for the lognormal distribution are not the same mu and sigma as the normal distribution. Pretty obvious in hindsight, but I think it's possible to convert one to the other. – MPath Mar 7 '17 at 11:15


text:
# Why do similar matrices represent the same linear transformation? [duplicate]

I don’t understand the theorem:

$$A$$ and $$B$$ are similar if and only if they represent the same linear transformation.

I know one direction "If $$A$$ and $$B$$ represent the same linear transformation then they are similar", but why is the other direction also true? (I did only basic linear algebra so could you please give an easy proof if possible! Or any intuitions for this theorem! Thank you!)

• Just write down what a change of basis amounts to, for a matrix. – Jean-Claude Arbaut Nov 24 '18 at 0:06
• Whether this is a duplicate is whether the core of the confusion is regarding "How is similarity equivalent to the transformations being written in different bases" or "How does the transformation being the same in different bases mean they are the same transformation". – Acccumulation Nov 24 '18 at 1:05

This is quite a long post, and it goes into a lot more detail than is perhaps necessary, but I felt it was important to be thorough. For the sake of simplicity, I'm going to restrict to linear transformations from a vector space $$V$$ to itself, also known as linear operators. This is really the only situation in which talking about similarity of matrices is meaningful, since it assumes that each matrix will use only one basis for both its input and its output.

## Part I Setting Up the Stage

It's important to understand here in what sense $$A$$ and $$B$$ are representing the same linear transformation, and really in what sense they represent a linear transformation at all. The crucial thing to keep in mind is that each matrix is representing a particular linear transformation with respect to a specific basis. Generally, when we go writing down matrices, the basis we're working with is implicit and often it isn't even actually mentioned since there is an implicit understanding of what the basis is that we're working with. This can be quite confusing however when you learn linear algebra for the first time as it can create a lot of potential for glossing over important distinctions, or even completely failing to notice them.

In particular, what linear transformation a matrix represents will change depending on what basis you are using. That is, the same matrix will represent different linear transformations in different bases. Therefore, for $$A$$ and $$B$$ to represent the same linear transformation $$T$$, there has to be a basis $$\beta_1$$ such that $$A$$ represents $$T$$ with respect to $$\beta_1$$, and a basis $$\beta_2$$ such that $$B$$ represents $$T$$ with respect to $$\beta_2$$. If you happen to be considering $$A$$ and $$B$$ with respect to the same basis, then of course they will represent different transformations. (After all, they could be representing similar operators.)

What the theorem actually says, then, is that $$A$$ and $$B$$ can only represent the same linear transformation, each of them with respect to some basis, if they are similar matrices. That is, if $$A$$ and $$B$$ are not similar, then there is no way we can pick our bases so that $$A$$ represents the same linear transformation with respect to the first basis as the transformation that $$B$$ represents with respect to the second basis. Conversely, if $$A$$ and $$B$$ are similar matrices, then we can always find a pair of bases $$\beta_1$$ and $$\beta_2$$ such that $$A$$ represents the same transformation with respect to $$\beta_1$$ as $$B$$ represents with respect to $$\beta_2$$.

## Part II Change of Basis

To see why this works requires understanding the concept of change of basis. That is, we need to understand how the matrix that represents a particular transformation changes as we change the basis with respect to which we want to express that linear transformation. So, given some transformation $$T$$ which is represented by the matrix $$T_1$$ with respect to a basis $$\beta_1$$, and given some other basis $$\beta_2$$ which we would like to express $$T$$ with respect to, how can we find the matrix that does so? To do this we have to construct the change of basis matrix.

Let's say that the matrix that expresses $$T$$ relative to $$\beta_2$$ is $$T_2$$. Given some vector $$v \in V$$ expressed with respect to $$\beta_2$$ as a column vector, we expect that when we multiply the matrix $$T_2$$ by $$v$$ we get a column vector $$T_2v$$ that expresses $$T(v)$$ with respect to $$\beta_2$$. We should think of the matrix $$T_2$$ as taking in a vector expressed with respect to $$\beta_2$$ and spitting out what the transformation $$T$$ does to that vector, expressed with respect to $$\beta_2$$.

What we have so far is a way of taking in a vector expressed with respect to $$\beta_1$$, and spitting out what the transformation does to that vector expressed with respect to $$\beta_1$$. This is given by the matrix $$T_1$$. So what we need is some way of taking a vector expressed with respect to $$\beta_2$$, and finding out how to express it with respect to $$\beta_1$$. That way, we can feed in that vector expressed with respect to $$\beta_1$$ to our matrix $$T_1$$, which will then dutifully spit out what $$T$$ does to that vector expressed with respect to $$\beta_1$$, when we multiply $$T_1$$ by that vector. Since the output is now expressed with respect to $$\beta_1$$, we also need some way of taking that output and expressing it with respect to $$\beta_2$$, which will then complete the process.

Let's have $$\beta_1 = \{e_1,\ldots,e_n\}$$ and $$\beta_2 = \{f_1,\ldots f_n\}$$. When we write down a vector $$v$$ with respect to $$\beta_2$$, what we have is $$v = v_1f_1 + v_2f_2 + \cdots v_nf_n$$, where the $$v_i$$'s are the coefficients of $$v$$ with respect to $$\beta_2$$. Therefore, if we could just write down the vectors of $$\beta_2$$ with respect to $$\beta_1$$, we could then add up that entire linear combination to find out what $$v$$ looks like with respect to $$\beta_1$$. That is, we want $$f_1 = f_{11}e_1 + f_{21}e_2 + \cdots + f_{n1}e_n$$ so that the $$f_{i1}$$'s are the coefficients of $$f_1$$ with respect to $$\beta_1$$. Similarly, we want $$f_2 = f_{12}e_1 + f_{22}e_2 + \cdots + f_{n2}e_n$$ so that the $$f_{2i}$$'s are the coefficients of $$f_2$$ with respect to $$\beta_1$$. Proceeding onward, we want $$f_j = f_{1j}e_1 + f_{2j}e_2 + \cdots + f_{nj}e_n$$ for $$1 \le j \le n$$, so that the $$f_{ij}$$'s are the coefficients of $$f_j$$ with respect to $$\beta_1$$. Then we find that \begin{aligned} v = v_1f_1 + v_2f_2 + \cdots v_nf_n = \hspace{1mm}&v_1(f_{11}e_1 + f_{21}e_2 + \cdots + f_{n1}e_n) \hspace{1mm} + \\ &v_2(f_{12}e_1 + f_{22}e_2 + \cdots + f_{n2}e_n) \hspace{1mm} + \\ &\hspace{2cm} \vdots \\ &v_n(f_{1n}e_1 + f_{2n}e_2 + \cdots + f_{nn}e_n) \\ = \hspace{1mm} &\hspace{4mm} (v_1f_{11} + v_2f_{12} + \cdots + v_nf_{1n})e_1 \hspace{1mm} + \\ &\hspace{4mm} (v_1f_{21} + v_2f_{22} + \cdots + v_nf_{2n})e_2 \hspace{1mm} + \\ &\hspace{2cm} \vdots \\ &\hspace{4mm} (v_1f_{n1} + v_2f_{n2} + \cdots + v_nf_{nn})e_n \end{aligned} This looks exactly like matrix multiplication. This inspires us to package together all those $$f_{ij}$$'s into a single matrix $$M = [f_{ij}]$$, and observe that we can express $$v$$ as a column vector with respect to $$\beta_1$$ like so: $$v = \begin{bmatrix} f_{11} & f_{12} & \cdots & f_{1n} \\ f_{21} & f_{22} & \cdots & f_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ f_{n1} & f_{n2} & \cdots & f_{nn} \end{bmatrix} \begin{bmatrix} v_1 \\ v_2 \\ \vdots \\ v_n \end{bmatrix}$$ where the $$v_i$$'s are again the components of $$v$$ with respect to $$\beta_2$$. So we've got exactly what we wanted - we have a matrix $$M$$ that when we muliply it by any vector expressed with respect to $$\beta_2$$, we get the same vector expressed with respect to $$\beta_1$$. The matrix $$M$$ that we just constructed is called the change of coordinates matrix, since it changes the coordinates with respect to which the vector is expressed. Now we need a way of going in the opposite direction - that is, taking a vector expressed with respect to $$\beta_1$$ and expressing it in terms of $$\beta_2$$. The matrix that will do this for us is $$M^{-1}$$. Can you see why? It is precisely the matrix that "undoes" the action that $$M$$ does, so it has to be the inverse matrix of $$M$$. Perhaps a bit counterintuitively, the matrix $$M^{-1}$$ is called the change of basis matrix. This will give us everything we need. The matrix that expresses $$T$$ with respect to $$\beta_2$$ is as follows: $$T_2 = M^{-1}T_1M$$ Again, do you see why? When you multiply $$T_2$$ by a vector expressed with respect to $$\beta_2$$, first it gets multiplied by $$M$$, so that it is now expressed with respect to $$\beta_1$$. The matrix $$T_1$$ then takes this vector and gives you what $$T$$ does to it expressed in terms of $$\beta_1$$, and then the matrix $$M^{-1}$$ then takes this vector and expresses it back in terms of $$\beta_2$$, thus completing the process.

## Part III Wrapping It Up

Now that we know how to express a linear transformation with respect to arbitrary bases, it should really seem quite obvious why similarity is necessary for two matrices two represent the same transformation, and you have mentioned that that part seems to make sense to you. It's essentially baked into the process! What about the other direction? Well, if we can find a matrix $$M$$ such that $$B = M^{-1}AM$$, then we can think of $$M$$ as being the change of coordinates matrix. That is, we think of $$M$$ as taking vectors expressed with respect to the basis we are using for $$B$$, and expressing them with respect to a new basis with respect to which $$A$$ represents the same transformation. So any two matrices that are similar can represent the same linear transformation if you pick the right bases.

• I have already passed linear algebra more than a year ago, but back then I was a beggining student that didn't really understand exactly what do with himself, how to study and how to approach math, now I am finishing my second year (I am studying pure math) and I am way mpre mature in the aspect of approching and understanding math. I studied about similar matrices again this semester in a course on rings and modules, and then I realized that I don't really understand similar matrices. This is exactly what I needed thanks a lot! – Tair Galili Jul 15 '20 at 10:41

Fact 1) Any invertible matrix can be seen as a matrix of change of basis

This happens because every bijective linear function from $$X$$ to $$X$$ determines a change of basis (and hence a change of basis matrix).. your new basis will be $$\{f(a_i): i=1,\cdots,n\}$$ where $$\{a_i: i=1,\cdots,n\}$$ is the old basis.

Knowing this, you can reinterpret $$A=CBC^{-1}$$.

Consider that $$A$$ represent some operator $$T$$ in a basis $$\alpha$$ of $$X$$, i.e., $$A=[T] ^{\beta}_ {\beta}$$. This is possible because the space of all $$n\times n$$ matrix is isomorphic to the space of all linear operators of a $$n$$-dimensional space $$X$$.

Then use Fact 1 to say that $$C^{-1}$$ determines a change of basis from $$\beta$$ to some basis $$\alpha$$, i.e., $$C^{-1}=[I]^{\beta} _ {\alpha}$$. You can prove that this implie $$C=[I]^{\alpha}_ {\beta}$$.

And finally you will have $$B=C^{-1}AC =[I]^{\beta}_ {\alpha}[T] ^{\beta}_ {\beta}[I]^{\alpha} _ {\beta}$$, which is exactly saying that $$B=[T]^ {\alpha}_{\alpha}$$ . That is, $$A$$ and $$B$$ are just different ways to represent the same linear transformation.


text:
# Tag Info

1

How can we see that the group $N$ generated by $$g = (e^{2\pi i/3} I, -I, e^{i\pi /3}) \in SU(3)\times SU(2)\times U(1)$$ acts trivially on all fields in the Standard Model? First of all, note that $g$ is in the center of $SU(3)\times SU(2)\times U(1)$. Therefore its representative in the adjoint representation is the identity. Since gauge bosons ...

0

The main point is that if one has a consistent gauge theory with matter with gauge group $$G:=SU(3)\times SU(2)\times U(1),$$ if one divides $G$ with a normal subgroup $N$, the matter representations of the matter fields could potentially become multi-valued. However, it is possible to choose $N=\mathbb{Z}_6$ in such a way that the standard model matter ...

1

Baez actually has another paper (with Huerta) that goes into more detail about this. In particular, Sec. 3.1 is where it's explained, along with some nice examples. The upshot is that the hypercharges of known particles work out just right so that the action of that generator is trivial. Specifically, we have Left-handed quark Y = even integer + 1/3 ...

7

Color charge in the sense of "being blue, red, green" is not a quantum mechanical observable because the $\mathrm{SU}(3)$ gauge transformations mix the colors. This means it is meaningless to say "We have a blue particle", because we can perform a gauge transformation and then we "have a red particle". Since physical descriptions related by gauge ...

0

My "answer" to this question is, for the moment at least, do more reseach and update this current note with more details as I discover them. I am reluctant to withdraw this question for the moment, I asked it ahead of myself and my knowledge level but I will return to it, even if only for my own personal notes. The answer to my question may lie in a ...

0

I can think some speculative or unorthodox answers, and sure others can do, so please allow me to mark this answer as Community Wiki: three generations make a nice number of degrees of freedom for a GUT model. Assuming that the neutrinos have companions of the other chirality, one generation has 36 degrees of freedom. With this, the MSSM happens to have ...

-3

The relativistic mass of the photon is not zero, it is $\frac{h\nu}{c^2}$. The rest mass of the photon is zero, but according to spec. rel it goes always with $c$.

-2

No, there are just spin-0, spin-1 and spin-1/2 particles, even the Higgs-Boson is 0.

1

The VEV is quantum mechanical, it can not be read off from the Lagrangian. To find the VEV from the potential requires one to quantise the theory, then calculate the effective action at strong coupling. What should happen is that at strong coupling the quarks form hadrons; which are quark condensates. To perform the calculations is very tough and not yet ...

1

In addition to TwoBs' comments, in the 90s, there had been many collisions at SLAC (USA) with polarized electron/positron beams of the SLC collider running at the $Z$ pole. Therefore, the right handed component of the electroweak interaction has been extensively tested. See the wikipage: http://en.wikipedia.org/wiki/SLAC_National_Accelerator_Laboratory

3

Is there something wrong with this process? (it will admittedly be suppressed by $|V_{su}|^2\approx \frac{1}{20}$, i.e. "doubly cabbibo suppressed") or maybe even replace the Z boson with gluons.

4

Is there anyone knowledgable enough in this area who would be able to comment on some of the possible theoretical/ hypothetical implications of the existence of spin 3 particles? Is there any thought that their existence could imply additional fundamental forces? If you look at the presentation linked in the link you gave , in page five, you will see ...

0

As ACuriousMind said, the fact that the particle is composite makes it less earth-shattering. The interesting thing here (I think...not a high-energy guy) is that it's the first example of this kind of spin-3 particle, in particular flavored. Other composite spin-3 particles have been known before, the first one I found was a Boron nucleus.

2

Yes, wikipedia has a table which lists the 19 free parameters that need to be tuned by experiments. These include, as you already said, the masses of the elementary particles including the Higgs Boson, and some other notable ones are: CKM Mixing angles and CP-violation phase. Gauge coupling of he three symmetries (U(1), SU(2), SU(3)). Higgs VEV

Top 50 recent answers are included


text:
# All Questions

27 views

### Spotting humps in implied volatility term structure

Sometimes implied volatility term structure performs a hump shape. How can I measure the frequency of hump appearence? Basically, I have several years of daily data on IV TS, how can I count the ...
40 views

### Understanding the necessary and sufficient conditions for rational early exercise of a call option

I am self-studying for an actuarial exam, and I encountered the following in my text: The author states that if $PV_{t, T}\text{(Divs)} < K(1 - e^{-r(T - t)})$, early exercise is not rational. ...
393 views

Yahoo offers an API to download historical intraday data, but I am unable to understand the timestamps on the data. The URL request is: ...
135 views

### CDO selling or buying credit protection?

I think there is an error in the Meissner text - Correlation Risk Modeling and Management and can't find an errata for this text to verify. On page 19 the foot note reads: Shorting the equity ...
10 views

### How to create prospective Bonds for a dynamic portfolio simulation?

The aim is to simulate and to compare different bond portfolio strategies for different interest rate scenarios over ten years. The rebalancing takes place on an annual basis. Hence, e.g. a bond with ...
26 views

### dollar neutral ratio vs beta hedged ratio

Hi guys i really hope you can help as i've been pulling out my hair for days on this!! OK so basically i understand the dollar neutral ratio, simply stocka/stockb = dollar neutral ratio. Works great ...
87 views

An increase in default correlation ceteris paribus increases the value of the equity tranche of a CDO. This I get. How then, do I make sense of the statement that as default correlation in the ...
184 views

### Formula behind pandas.Options() implied volatility

I noted that implied volatility (IV field) from pandas.Options class is very different (especially, for out of money options) than what I compute with Black-Scholes model. (risk free rate is pulled ...
29 views

29 views

### Construction of bond portfolio represented by a CDS-Index

Markit publishes investable basket CDS indices. These are indices intended to track the credit risk of a basket of issuers (e.g. in the case of iTraxx Europe Series 24 these are 125 names) in an ...
122 views

### Calculating expected shortfall

I'm trying to calculate the expected shortfall for the below scenario. I don't understand why the 1.04% probability of 0 bonds defaulting is used as a weight when calculating ES, since the binomial ...
99 views

### How to get list of large intraday movers for that day?

Is there a source (preferably free :) that provides a list of large intraday (versus pre market) movers for the day you look? I don't mind getting the list on market close. I don't need historical ...


text:
G. Indie Album
time limit per test
3 seconds
memory limit per test
512 megabytes
input
standard input
output
standard output

Mishka's favourite experimental indie band has recently dropped a new album! Songs of that album share one gimmick. Each name $s_i$ is one of the following types:

• $1~c$ — a single lowercase Latin letter;
• $2~j~c$ — name $s_j$ ($1 \le j < i$) with a single lowercase Latin letter appended to its end.

Songs are numbered from $1$ to $n$. It's guaranteed that the first song is always of type $1$.

Vova is rather interested in the new album but he really doesn't have the time to listen to it entirely. Thus he asks Mishka some questions about it to determine if some song is worth listening to. Questions have the following format:

• $i~t$ — count the number of occurrences of string $t$ in $s_i$ (the name of the $i$-th song of the album) as a continuous substring, $t$ consists only of lowercase Latin letters.

Mishka doesn't question the purpose of that information, yet he struggles to provide it. Can you please help Mishka answer all Vova's questions?

Input

The first line contains a single integer $n$ ($1 \le n \le 4 \cdot 10^5$) — the number of songs in the album.

Each of the next $n$ lines contains the desciption of the $i$-th song of the album in the following format:

• $1~c$ — $s_i$ is a single lowercase Latin letter;
• $2~j~c$ — $s_i$ is the name $s_j$ ($1 \le j < i$) with a single lowercase Latin letter appended to its end.

The next line contains a single integer $m$ ($1 \le m \le 4 \cdot 10^5$) — the number of Vova's questions.

Each of the next $m$ lines contains the desciption of the $j$-th Vova's question in the following format:

• $i~t$ ($1 \le i \le n$, $1 \le |t| \le 4 \cdot 10^5$) — count the number of occurrences of string $t$ in $s_i$ (the name of the $i$-th song of the album) as a continuous substring, $t$ consists only of lowercase Latin letters.

It's guaranteed that the total length of question strings $t$ doesn't exceed $4 \cdot 10^5$.

Output

For each question print a single integer — the number of occurrences of the question string $t$ in the name of the $i$-th song of the album as a continuous substring.

Example
Input
20
1 d
2 1 a
2 2 d
2 3 a
2 4 d
2 5 a
2 6 d
2 7 a
1 d
2 9 o
2 10 k
2 11 i
2 12 d
2 13 o
2 14 k
2 15 i
2 1 o
2 17 k
2 18 i
2 15 i
12
8 da
19 doki
19 ok
16 doki
15 doki
9 d
1 a
20 doki
Output
4
3
3
2
0
1
1
2
1
1
0
2
Note

Song names of the first example:

1. d
2. da
9. d
10. do
11. dok
12. doki
13. dokid
14. dokido
15. dokidok
16. dokidoki
17. do
18. dok
19. doki
20. dokidoki

Thus the occurrences for each question string are:

1. string "da" starts in positions $[1, 3, 5, 7]$ in the name "dadadada";
2. string "dada" starts in positions $[1, 3, 5]$ in the name "dadadada";
3. string "ada" starts in positions $[2, 4, 6]$ in the name "dadadada";
4. string "dada" starts in positions $[1, 3]$ in the name "dadada";
6. string "doki" starts in position $[1]$ in the name "doki";
7. string "ok" starts in position $[2]$ in the name "doki";
8. string "doki" starts in positions $[1, 5]$ in the name "dokidoki";
9. string "doki" starts in position $[1]$ in the name "dokidok";
10. string "d" starts in position $[1]$ in the name "d";
12. string "doki" starts in positions $[1, 5]$ in the name "dokidoki".


text:
# French Theoremstyle

\documentclass[french]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{babel}
\usepackage{amssymb,amsfonts}
\usepackage{amsmath}
\usepackage{amsfonts}

\theoremstyle{definition}

\begin{document}

\end{document}

I am working in a French Environment and I am getting the error "Undefined control sequence. l.12 \theoremstyle {definition}". Most probably Theoremstyle is not defined for the French Environment. How should I write it?

• You need either amsthm or ntheorem. I usually recommend the former. – egreg May 13 '18 at 9:56

You will need to load the package amsthm, I have attached an example below:

\documentclass[french]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{babel}
\usepackage{amssymb}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amsthm}

\theoremstyle{definition}

\newtheorem{theorem}{Théorème}
\newtheorem{lemma}[theorem]{Lemme}
\newtheorem{corollary}[theorem]{Corollaire}
\newtheorem{proposition}[theorem]{Proposition}
\newtheorem{definition}{Définition}
\newtheorem{example}[theorem]{Exemple}
\newtheorem{remark}{Remarque}
\newtheorem{notation}[theorem]{Notation}

\begin{document}
\begin{theorem}
Mon nouveau théorème
\end{theorem}

\begin{proof}
Et voila
\end{proof}

\end{document}

Then you can fine tune how your environments (theorem, definition, corollary, etc) will behave. I have added a few environments in the code above along with their French names.

Hope that helps.

Romain

• I suppose you want to load babel with the french option. – GuM May 13 '18 at 10:16
• @GuM: No, since version 3.10, language options of babel should be loaded with the document class, so all language-dependent packages be informed. – Bernard May 13 '18 at 12:01
• @Bernard: You know what? I didn’t notice the french option passed to the document class… :-) – GuM May 14 '18 at 8:50
• @GuM: Speed reading? ;o) – Bernard May 14 '18 at 8:56
• off topic: sinceamssymb loads amsfonts, it's not necessary to do that separately. – barbara beeton May 14 '18 at 12:10