Want to get started on ab testing? You probably have to first understand hypothesis testing and the following 4 terms:

- Type I Error
- Type II Error
- Sample Size
- Power

- Some python (or any other programming languages)
- Understanding of basic statistics (High school would be sufficient)
- Basic distributions, pdf, cdf.
- expected value, variance.
- central limit theorem, confidence intervals, z-score.

`requirements.txt`

:

```
numpy==1.19.4
pandas==1.1.5
statsmodels==0.12.1
matplotlib==3.3.3
```

Before we dive in, let's start by generating some random numbers:

In this example, we will use exponential distribution (but you wouldn't know this in real life) - so let's play along:

The exponential function is defined as :

f(x, \beta) =
\begin{cases}
\frac{1}{\beta}e^{(-x/\beta)}& x \ge 0 \\\\
0 & x < 0
\end{cases}

E[X] = \frac{1}{\beta},
Var[x] =\frac{1}{\beta^2}

Note, some sites refer exponential function with the rate \lambda parameter with \lambda = 1/\beta.

Now let's import some libraries, define a python function, and generate some random numbers:

```
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as st
def gen_exp(n_samples: int, size_sample: int, scale_input: float) -> np.ndarray:
"""[summary]
Args:
n_samples (int): [number of samples]
size_sample (int): [each sample size]
scale_input (float): [the exponential distribution scale parameter]
Returns:
np.ndarray: [returns a n_sample x size_sample ndarry]
"""
np.random.seed(100)
values: np.ndarray = np.random.exponential(
scale=scale_input, size=(n_samples, size_sample)
)
return values
# dummy generated data
eg1_n = 10000
eg1_size = 500
eg1_scale = 5
eg1_var = eg1_scale ** 2
# ------
# Null hypothesis, we assume the mu0 to be 5
eg1_data = gen_exp(n_samples=eg1_n, size_sample=eg1_size, scale_input=eg1_scale)
eg1_means = np.mean(eg1_data, axis=1)
```

To summarize, this is what the code did:

- generate some data (that follows exponential distribution)
- calculate sample mean
- The population variance is known (more on this in t-test if you do not know your population variance) to calculate z-statistics \frac{x-\mu}{\sigma/\sqrt{n}}.

In the above setup, 10000 different samples of size 500 each are generated. In reality, you would only have 1 such sample. E.g suppose you are running a factory line, and you take 0.1% of your supply chain to take measurements. But lets assume somehow you magically are able to take measurements of all your supply chain.

Now, suppose you want to test whether the assumed population mean (null hypothesis \mu_0) is equals to \mu_0 = 0.5 (which is the scale parameter) we have to calculate the standardized z-score:

Z = \frac{\bar{x}-\mu_0}{\sigma / \sqrt{n}}

```
null_mean = 5
eg1_z_score = ((eg1_means) - null_mean) / (eg1_var ** 0.5 / eg1_size ** 0.5)
print(eg1_z_score)
"""
array([ 0.34787201, 0.1295498 , -1.64761934, ..., -2.05800225,
0.25049453, 0.70433965])
"""
```

Recall that the distribution of sample means follows normal distribution (due to central limit theorem).

Z = \frac{\bar{X}-\mu}{\sigma/\sqrt{n}}

Where:

- \bar{X} is the sample mean.
- \mu is the population mean.
- \sigma is the population variance.
- n is the sample size.

Further more, your management decides to have a 95% confidence level (explained further later).

```
error_rate = 0.05
critical_region = st.norm.ppf(error_rate / 2)
eg1_rejected = (eg1_z_score > -critical_region) | (eg1_z_score < critical_region)
print(sum(eg1_rejected) / eg1_n)
"""
0.049
# Notice that this is almost the same as error_rate
"""
```

We will now introduce a few terms:

- The
`hypothesis test`

`alpha`

\alpha`Type I error`

`P-value`

In hypothesis testing, we always come up with a `null`

hypothesis and an `alternative`

hypothesis.

The `null`

and `alternative`

are two opposing roads. The null is either rejected or it is not. Only if the null is rejected, can we proceed to the alternative. The "alternative" is simply the other option when the null is rejected; nothing more.

H_0 | H_a |
---|---|

Assumption, status quo, nothing new | Rejection of an assumption |

Assumed to be "True"; a given. | Rejection of an assumption or the given |

Negation of the research question | Research question to be "proven" |

Always contains an equality =, \leq,\geq | Does not contain equality \neq,<,> |

In any hypothesis testing, we assume that the null is equal to some values, while the alternative is not equal, i.e a two tailed test such as the example above.

We can also assume the null to be less than or greater than a certain value while the alternative is the opposite that would result in a one tailed test.

- H_0 =, H_a \neq
- H_0 \leq, H_a >,
- H_0 \geq, H_a <

In a two tail test with error rate `0.05`

, it means that for any `z-statistics`

lower than `-1.96`

or higher than `1.96`

are rejected (this has to do with confidence interval).

```
st.norm.ppf(0.975) # 1 - alpha/2, alpha = 0.05
"""
1.959963984540054
"""
```

In the earlier example, this would be our hypothesis:

H_0 = 0.5, H_a \neq 0.5

In some sense, z-scores that are above or lower than the critical region are out-liers or extreme points under the (normal) distribution curve that will result in rejection of the null hypothesis.

- All statistical conclusions are made in reference to the null hypothesis.
- As researchers we either
**reject**the null hypothesis or**fail to reject**the null hypothesis; we do not**accept**the null. - This is due to the fact that the null hypothesis is assumed to be true from the start; rejecting or failing to rejection an assumption.
- If we
**reject**the null hypothesis, then we conclude the data supports the alternative hypothesis. - however if we
**fail to reject**the null hypothesis, it does not mean we have proven the null hypothesis is "true".

In the earlier example, **all samples** are actually all **true**; they came from the same distribution, they are **expected** to have the mean 0.5 but yet some of them got rejected!

let's take a look at some of the sample means that got rejected:

```
eg1_means[eg1_rejected][0:10]
"""
array([5.44087673, 5.49711468, 4.55158478, 5.56972674, 5.46925766,
5.74871525, 4.51424667, 5.59588691, 4.41574811, 4.50385256])
"""
```

Hmm, the values are about 10% (0.05) away from the mean (0.5)!

Indeed, if we see the rejected z-scores means they do seem like outlier if we observe their z-statistics!

```
eg1_z_score[eg1_rejected][0:10]
"""
# z-scores that got rejected
array([ 1.97166068, 2.22316444, -2.00537382, 2.54789543, 2.09858404,
3.3483564 , -2.17235491, 2.66488728, -2.61285386, -2.21883879])
"""
```

This error is known as Type I error and is represented by \alpha, which is formally defined as:

`Alpha`

α is the probability of rejecting the null hypothesis when the null hypothesis is true. This is also sometimes referred as`significance level`

.

`Alpha`

\alpha is also known as `Type I error`

which is also known as `false positive`

.

The formal definition of `type I error`

:

The type I error rate or significance level is the probability of rejecting the null hypothesis given that it is true. It is denoted by the Greek letter α (alpha) and is also called the alpha level.

We will now refer type I error as alpha \alpha.

In the earlier example, when we look at the "extreme" z-scores, we notice that they are "rare" chances of occurring, the question is, how rare? This is where p-values come in.

For the formal definition (which is kinda hard to understand):

In null hypothesis significance testing, the p-value is the probability of obtaining test results at least as extreme as the results actually observed, under the assumption that the null hypothesis is correct.

Let's take a look at the same example:

Note that the P-value for a two-tailed test is always two times the P-value for either of the one-tailed tests.

```
alpha = 0.05
p_values = st.norm.sf(abs(eg1_z_score)) * 2 # twosided
print(sum(p_values < alpha))
print(p_values[eg1_rejected][0:10])
"""
# Number of values that got rejected
490
# P-values that got rejected
[0.04864836 0.02620471 0.0449231 0.0108375 0.03585358 0.00081292
0.0298289 0.00770141 0.00897897 0.02649769]
"""
```

This means that the probability of the rejected samples are quite rare!

- p-value is the chance that your sample data correctly reflects the population assuming your null hypothesis is true
- High p value : low surprise. A low p-value makes your default assumption looks stupid.
- Does the evidence we collected make our null hypothesis looks ridiculous?

The above example assumes that we know or is able to assume our population variance, this might not always be true. In that scenario, we use t-test.

As compared to the Z-distribution, the T-distribution is flatter - you want to "play safe" and act upon it. but as n \geq 30 it does not matter that much.

- A Smaller sample size means more sampling error. This sampling error due to small n means a higher probability of extreme sample means. When you only collect 1 sample, the sample could be extreme.
- Given the same \alpha and s, a smaller n will push the critical values further outward in the tail(s) due to the uncertainty associated with small n. - think of this as collecting evidence.
- As sample size increases for t-distribution, it "narrows" down the curve and making it sharper. The larger sample size n leads to a higher degree of freedom df.

For the T-test, we need to calculate Sample variance and degree of freedom.

S^2 = \frac{1}{n-1}\sum_i^n (x_i - \bar{x})^2

df = n-1

```
# dummy generated data
eg2_n = 20000
eg2_size = 20 # smaller sample size to show the difference
eg2_scale = 5
eg2_var = eg2_scale ** 2
eg2_data = gen_exp(n_samples=eg2_n, size_sample=eg2_size, scale_input=eg2_scale)
# ------
# Assume under the null hypothesis is 5
alpha = 0.05
null_hypo_mean = 5
eg2_means = np.mean(eg2_data, axis=1)
eg2_z_score = ((eg2_means) - null_hypo_mean) / (eg2_var ** 0.5 / eg2_size ** 0.5)
critical_region = st.norm.ppf(alpha / 2)
eg2_z_rejected = (eg2_z_score > -critical_region) | (eg2_z_score < critical_region)
print(sum(eg2_z_rejected) / eg2_n) # still approximately alpha
sample_s_vars = np.var(eg2_data, axis=1, ddof=1) # to calculate sample variance
t_statistics = ((eg2_means) - null_hypo_mean) / (
sample_s_vars ** 0.5 / eg2_size ** 0.5
)
critical_region = st.t.ppf(alpha / 2, df=len(t_statistics) - 1)
eg2_t_rejected = (t_statistics > -critical_region) | (t_statistics < critical_region)
print(sum(eg2_t_rejected) / eg2_n)
"""
0.0464 # % of type 1 error for z-test - still approximately alpha
0.09655 # % of type 1 error for t-test
"""
```

In the earlier example when we look at the rejected means,

```
eg1_means[eg1_rejected][0:10]
"""
array([5.44087673, 5.49711468, 4.55158478, 5.56972674, 5.46925766,
5.74871525, 4.51424667, 5.59588691, 4.41574811, 4.50385256])
"""
```

While for some cases,

```
eg1_means[~eg1_rejected][0:10]
"""
array([5.07778655, 5.02896822, 4.63158111, 4.64179313, 4.75966314,
5.07823713, 5.29718464, 5.1069177 , 5.04548296, 5.0073808 ])
"""
```

Notice that for means values such as `4.6315`

which is `5-4.6315 = 0.3685`

off, the hypothesis test did not reject the null hypothesis.

You might not be comfortable with this error, because `0.3685`

seems pretty far off, and you ensure that all values that are accepted must be within \pm 0.35.

In hypothesis testing, this is increasing the confidence level by increasing the sample size, but how much to increase? For this, we need to introduce Margin of Error:

In confidence interval, we have

\bar{X} \pm z_{\alpha/2} * \frac{\sigma}{\sqrt{n}}

If we want to have an interval such that:

\bar{X} \pm E

We can set:

E = z_{\alpha/2} * \frac{\sigma}{\sqrt{n}}

E is also known as the Margin of Error - sometimes annotated with m or MOE in literature.

The formal definition:

The margin of error is a statistic expressing the amount of random sampling error in the results of a survey.

To decrease E, we can decrease z which can be done by reducing \alpha, or we can increase our sample size n.

Rearranging the variables,

n = \bigg(\frac{z_{\alpha/2}* \sigma}{E} \bigg)^2

In the earlier example, we set \alpha = 0.05\ z_{\alpha/2} = 1.96\ \sigma=5 Suppose desired error is 0.35,

then:

n = (1.96 * 5 / 0.35)^2 = 784

Let's change the sample size to 784 as follows to see the impact of the rejected values.

```
# dummy generated data
eg3_n = 10000
eg3_size = 784
eg3_scale = 5
eg3_var = eg3_scale ** 2
eg3_data = gen_exp(n_samples=eg3_n, size_sample=eg3_size, scale_input=eg3_scale)
# -----
# under null hypothesis, mu0 = 5
alpha = 0.05
null_hypo_mean = 5
eg3_means = np.mean(eg3_data, axis=1)
eg3_z_score = ((eg3_means) - null_hypo_mean) / (eg3_var ** 0.5 / eg3_size ** 0.5)
critical_region = st.norm.ppf(alpha / 2)
eg3_z_rejected = (eg3_z_score > -critical_region) | (eg3_z_score < critical_region)
print(sum(eg3_z_rejected) / eg3_n)
print(eg3_means[eg3_z_rejected][0:10])
print(eg3_means[~eg3_z_rejected][0:10])
"""
0.0494 # still alpha
[4.6383495 5.35335695 5.37160384 5.37822502 5.45501496 4.53971264
5.41956301 4.47470486 4.50186932 5.41407206] # mean values beyond 0.35 error margin getting rejected
[5.06980888 4.67283548 4.70932442 5.14385203 5.15813739 5.0987326
4.96519985 5.21819036 5.03102888 4.89815293] # mena values within 0.35 error is still "accepted"
"""
```

Notice that:
- The value of alpha does not change.
- Values within 5 \pm 0.35 still get accepted
- Values out of 5 \pm 0.35 will be rejected.

There is still another type of error, up till now, we only introduced type I error where we wrongly rejected the null hypothesis when it is true. There is also another type of error - what if we fail to reject the null hypothesis, when it is actually false?

Note, for this guide we assume that we are able to acquire the true population variance (which is not possible in reality) - This is to illustrate the concept behind Type II Error & Power. In practice you might consider using sample variance and t-test instead!

Let's take a look at an example:

```
# generate dummy data, note that the data is now generated with a different parameter
eg4_n = 20000
eg4_size = 100
eg4_scale = 7
eg4_var = eg4_scale ** 2 # population variance is known
eg4_data = gen_exp(n_samples=eg4_n, size_sample=eg4_size, scale_input=eg4_scale)
# but we still assume under the null hypothesis to be equal to 5.
alpha = 0.05
eg4_means = np.mean(eg4_data, axis=1)
null_hypo_mean = 5
known_var=eg4_var # not possible in reality
eg4_z_score = ((eg4_means) - null_hypo_mean) / (known_var ** 0.5 / eg4_size ** 0.5)
critical_region = st.norm.ppf(alpha / 2)
num_rejected = (eg4_z_score > -critical_region) | (eg4_z_score < critical_region)
print(sum(num_rejected))
print(1-sum(num_rejected) / eg4_n) # Type 2 error
"""
16274 # number of samples accepted even though the true mean is not 5!
0.18630000000000002 # Type 2 error
"""
```

In reality, we should have rejected 100% of them, but we only rejected about 81% of them! So **we failed to reject 19% when the alternative is true.**

(In this case we know the alternative is 7, more on that later)

The formal definition:

The second kind of error is the failure to reject a false null hypothesis as the result of a test procedure. This sort of error is called a type II error (false negative) and is also referred to as an error of the second kind.

Type II error is also known as false negative, and the probability is represented \beta.

To calculate the Type II error,

- need to assume an alternative hypothesis.
- have to select a \mu_a that satisfies the alternative hypothesis to calculate the probability of Type II error
- Calculate the overlapping distributions under the null hypothesis and alternate hypothesis.

There is no "universal" type II error. It is different for every \mu_a that satisfies the alternative hypothesis.

H_0: \mu_0 = 5, H_a: \mu_a = 7

```
null_scale = 5 # mu0
alt_scale = 7 # mu_a, the specific value of the alternate hypothesis which happens to be the true distribution parameter.
known_sd = 7 # population s.d is known - which is based on the true population distribution
n = 100
alpha = 0.05
z_alpha = -st.norm.ppf(alpha / 2)
# Calculating the overlapping area by calculating the axis where the distributions overlap.
left_tail = -z_alpha + (null_scale - alt_scale) / (known_sd / n ** 0.5)
right_tail = z_alpha + (null_scale - alt_scale) / (known_sd / n ** 0.5)
type_2_error = st.norm.cdf(right_tail) - st.norm.cdf(left_tail)
print(type_2_error)
"""
0.18481101024000066 - approximately `eg4` type II error rate.
"""
```

Which is approximately same as example above `print(1-sum(num_rejected) / eg4_n)`

.

A little bit of mathematics to understand to understand the formula of `left_tail`

and `right_tail`

:

By definition, Type II error is defined as:

P( \text{accept }H_0 | H_a \text{ is true})

This happens when there is an intersection of of two distributions. To calculate this value, we need to calculate area under the curve where the two distributions overlap.

In a two tailed test:

\begin{align}
& P(|\bar{X}| < \bar{x}_{crit|H_0} | H_a ) \\
& = P( \bar{x}_{left,crit|H_0} < \bar{X} < \bar{x}_{right,crit|H_0} | H_a) \\
& = P( \frac{\bar{x}_{l,c|H_0} - \mu_a}{\sigma/\sqrt{n}} < Z < \frac{\bar{x}_{r,c|H_0}-\mu_a}{\sigma/\sqrt{n}} ) \\
& = P( \frac{\bar{x}_{l,c|H_0} - \mu_0 + \mu_0 - \mu_a}{\sigma/\sqrt{n}} < Z < \frac{\bar{x}_{r,c|H_0}- \mu_0 + \mu_0-\mu_a}{\sigma/\sqrt{n}} )\\
&= P( -z_{\alpha/2}+ \frac{\mu_0-\mu_a}{\sigma/\sqrt{n}}< Z < z_{\alpha/2} + \frac{\mu_0-\mu_a}{\sigma/\sqrt{n}} )
\end{align}

\frac{\mu_1 - \mu_2}{s} is also known as the Cohen's d effect size.

Thus the new left (and right) tail is given by the sum of null hypothesis z_\alpha and the difference between the two means divided by the sample variance.

`left_tail = -z_alpha + (null_scale - true_scale) / (known_var ** 0.5 / n ** 0.5)`

In order to control the Type II error, we need to first understand Statistical Power.

The formal definition:

The power of a binary hypothesis test is the probability that the test rejects the null hypothesis when a specific alternative hypothesis ) is true — i.e., it indicates the probability of avoiding a type II error.

Thus, by definition,

\text{Power} = 1 - \beta

In order to start understanding power, lets introduce an example:

The null hypothesis is assumed to be 5 and we want to estimate with 95% confidence with 0.5 margin of error.

```
Error_ci = 0.5
null_mean = 5 # this is x-bar
"""
In this case when we are using z-statistics, population variance is known.
And the population s.d is equal to the true population mean in this specific context
(which is the alternative hypothesis based on the artificially generated data)
"""
known_sd = 5.5
alpha = 0.05
z_alpha = -st.norm.ppf(alpha / 2)
sample_size = (z_alpha * known_sd / Error_ci) ** 2
print(sample_size)
"""
464.8165173039894
"""
```

In order to calculate Power (or type II error), we need to assume a specific value of the alternative hypothesis H_a = 5.5 as previously mentioned, given that the alternative hypothesis is equal to the null hypothesis plus the margin of error, we would expect the z-score would be exactly in the confidence interval boundary.

H_0: \mu_0 = 5, H_a : \mu_a = 5.5

```
alt_mean = 5.5
z_stats = (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
print(z_stats)
"""
The z-statistics which is the left tail at the two tail 95% confidence interval of the alternate hypothesis
-1.9599639845400547
"""
```

What is the probability of rejecting the null hypothesis H_0 = 5 when the alternative is true H_a=5.5? By intuition, it is exactly `0.5`

!

This is because you are at the confidence interval boundary, you are equally unsure on both distributions. To illustrate, recall the derivation above on calculating power:

\begin{align}
& P(|\bar{X}| < \bar{x}_{crit|H_0} | H_a ) \\
&= P( -z_{\alpha/2}+ \frac{\mu_0-\mu_a}{\sigma/\sqrt{n}}< Z < z_{\alpha/2} + \frac{\mu_0-\mu_a}{\sigma/\sqrt{n}} )
\end{align}

```
left_tail = -z_alpha + (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
right_tail = z_alpha + (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
type_2_error = st.norm.cdf(right_tail) - st.norm.cdf(left_tail)
power = 1 - type_2_error # %%
print(power)
"""
0.5000442877191609
"""
```

- Controlling \alpha is easy, simply choose
- Controlling \beta is abit more complicated
- The goal is to align the \alpha and \beta regions in the \mu_0 and \mu_a distributions respectively
- Since the means \sigma and critical values are set, we can "manipulate" the sample size n to generate a standard error that brings \alpha and \beta into alignment at c
- This new n will create a new \bar{x}_{crit} value for our decision rule.
- Since we are now controlling Type II error, we CAN use the phrases "reject H_0" or "accept H_0.

As mentioned previously, to control the Type II Error is also to control the power since they are related by the equation Power = 1 - \beta. The process of doing this is known as power analysis. Power analysis is normally conducted before the data collection.

The formal definition:

Power analysis is the procedure that researchers can use to determine if the test contains enough power to make a reasonable conclusion.

Alternatively,

Power is the probability that a test of significance will detect a deviation from the null hypothesis, should such a deviation exist.

There are a few ways to adjust the power:

- Adjusting \alpha - but unlikely to happen
- increasing sample size, in that case, how much to increase?

There are other ways but usually not feasible, for example:

- enforce a smaller margin of error by decreasing the variance across subjects - but you might not have control over your samples
- Changing it to one tail test - unless you are very confident in an actual study / very strong domain knowledge.

In order to control the Power by sample size, we need to decide on the effect that we want to detect. For example, if there is a derivation of 0.5 that is present, we want to have a 80% chance of detecting it. We can formulate this with the following hypothesis:

H_0 = 5, H_a = 5.5

There are online calculators such as this or that as well as libraries that are available for free. Feel free to try it out with:

- Power 1-\beta = 0.8
- Type I error rate \alpha = 0.05 or 5\%
- True mean \mu_a \text{ or } \mu_1= 5.5
- Null mean \mu_0 = 5
- known s.d \sigma = 5.5

```
z_alpha = st.norm.ppf(1 - 0.01/2)
# Alpha value at right tail since alternative is bigger than null
z_beta = st.norm.ppf(0.8) # Beta power = 0.8
null_mean = 5
alt_mean = 5.5
known_sd = 5.5
# Derivation of this formula is at the math section right after
sample_size = (z_alpha + z_beta) ** 2 * known_sd**2 / (null_mean - alt_mean) ** 2
print(sample_size)
"""
949.7144478562396
"""
```

To control our power to be a certain value - 0.8 in this case, is to restrict the overlaping area of the two distributions between the null and alternative hypothesis. In this case, since the alternative hypothesis is greater than the null hypothesis, the intersection point is where the right tail of the null hypothesis equates to the left tail of the alternative hypothesis:

\mu_0 + z_{\alpha/2} \frac{\sigma}{\sqrt{n}}=\mu_a - z_\beta\frac{\sigma}{\sqrt{n}}

Solving for n gives us:

n = \frac{(z_a+z_\beta)^2 \sigma^2}{(\mu_0 - \mu_a)^2}

To verify our new `sample_size`

where `z_beta = st.norm.ppf(0.8)`

:

```
alt_mean = 5.5
known_sd = 5.5
null_mean = 5
alpha = 0.05
z_beta = st.norm.ppf(0.8)
z_alpha = -st.norm.ppf(alpha / 2)
# our new sample size
sample_size = (z_alpha + z_beta) ** 2 * known_sd ** 2 / (null_mean - alt_mean) ** 2
print(sample_size)
z_stats = (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
print(z_stats)
left_tail = -z_alpha + (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
right_tail = z_alpha + (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
type_2_error = st.norm.cdf(right_tail) - st.norm.cdf(left_tail)
power = 1 - type_2_error # %%
print(power)
"""
949.71444785624 # This is the sample required to have 80% power
-2.801585218112969
0.8000009605622265
"""
```

As we are collecting more data which resulted in a larger sample size, we are now "more" certain that the null hypothesis should be rejected.

Alternatively, we can also `decrease the error`

- which is usually not possible in practice.

In the earlier example, when the alternative hypothesis H_a = 5.5 with 95% confidence interval, 0.5 margin of error, the power \beta = 0.5. To increase the power by 0.3, we can decrease the margin of error by 30%.

```
# Increase in power = 0.3
# 0.5 * (1- increase in power ) = 0.5 * 0.7 = 0.35
Error_ci = 0.35
null_mean = 5
known_sd = 5.5
alpha = 0.05
z_alpha = -st.norm.ppf(alpha / 2)
sample_size = (z_alpha * known_sd / Error_ci) ** 2
print(sample_size)
alt_mean = 5.5
z_stats = (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
print(z_stats)
left_tail = -z_alpha + (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
right_tail = z_alpha + (null_mean - alt_mean) / (known_sd / sample_size ** 0.5)
type_2_error = st.norm.cdf(right_tail) - st.norm.cdf(left_tail)
power = 1 - type_2_error # %%
print(power)
"""
948.6051373550805 # Sample size required
-2.7999485493429357 # z-score
0.7995424479338836 # power
"""
```

As expected, the result is similar. Thus, with a power of 80% to detect an difference of 0.5, any deviation from 5 \pm 0.35 will result in the rejection of the null hypothesis and conclude that the evidence is supportive of the alternative hypothesis.

How much to adjust alpha is not straight forward, and is usually done by plotting power curves.

For example, to get a power of 0.8 in the same example, we increase \alpha from 0.05 to 0.266.

```
Error_ci = 0.5
sample_mean = 5
known_sd = 5.5
alpha = 0.266 # increase from 0.05 to 0.25
z_alpha = -st.norm.ppf(alpha / 2)
sample_size = (critical_region * known_sd / Error_ci) ** 2
print(sample_size)
alt_mean = 5.5 # or the alteranate hypothesis mean
z_stats = (sample_mean - alt_mean) / (known_sd / sample_size ** 0.5)
print(z_stats)
left_tail = -z_alpha + (sample_mean - alt_mean) / (known_sd / sample_size ** 0.5)
right_tail = z_alpha + (sample_mean - alt_mean) / (known_sd / sample_size ** 0.5)
type_2_error = st.norm.cdf(right_tail) - st.norm.cdf(left_tail)
power = 1 - type_2_error # %%
print(power)
"""
464.8165173039894
-1.9599639845400547 # This value is less than z_alpha of -1.111, so we reject null hypothesis
0.8027436164758492 # but the power has increased to 0.8
"""
```

The following table gives a summary of the 4 scenarios of hypothesis testing.

Null is true | Null is false | |
---|---|---|

Decision about null Don't reject |
Correct Inference (true negative = 1-\alpha) significance level |
Type II error (False negative = \beta) |

Decision about null Reject |
Type I error (false positive = \alpha) |
correct Inference (true positive = 1-\beta) power |

- A Gentle Introduction to Statistical Power and Power Analysis in Python
- Wikipedia links
- Useful definitions
- Understanding P-value
- Power calculators
- What is power? What affects statistical power?