STEPS:
1. State H₀ (null) and H₁ (alternative)
2. Choose significance level α (usually 0.05)
3. Collect data and calculate test statistic
4. Calculate p-value (P(data|H₀ true))
5. Decision: p < α → reject H₀ | p ≥ α → fail to reject H₀

TYPES OF ERROR:
  Type I (α):  Reject H₀ when it's true  (false positive)
  Type II (β): Fail to reject H₀ when false (false negative)
  Power = 1 - β = P(correctly rejecting false H₀)

ONE-TAILED vs TWO-TAILED:
  H₁: μ > μ₀   (one-tailed, right)
  H₁: μ < μ₀   (one-tailed, left)
  H₁: μ ≠ μ₀   (two-tailed — most common)

COMMON TEST STATISTICS:
  z-test (σ known): z = (x̄-μ₀)/(σ/√n)
  t-test (σ unknwn): t = (x̄-μ₀)/(s/√n), df=n-1
  Chi-square: χ² = Σ(O-E)²/E
  F-test: F = MSbetween/MSwithin

# General formula:
# CI = estimate ± critical_value × standard_error

# For population mean (σ known):
# CI = x̄ ± z_{α/2} × σ/√n
# z_{α/2}: 1.645 (90%), 1.960 (95%), 2.576 (99%)

# For population mean (σ unknown, use t):
# CI = x̄ ± t_{α/2, n-1} × s/√n

# For proportion:
# CI = p̂ ± z_{α/2} × √(p̂(1-p̂)/n)

# Python
from scipy import stats
import numpy as np

data = [12, 15, 14, 10, 13, 16, 11, 14, 15, 12]
n = len(data)
xbar = np.mean(data)   # 13.2
s = np.std(data, ddof=1)  # sample std

# 95% CI
ci = stats.t.interval(0.95, df=n-1, loc=xbar, scale=s/np.sqrt(n))
print(f"95% CI: ({ci[0]:.2f}, {ci[1]:.2f})")

# Simple linear regression: y = β₀ + β₁x + ε
# β₁ = Σ(xᵢ-x̄)(yᵢ-ȳ) / Σ(xᵢ-x̄)²
# β₀ = ȳ - β₁x̄

# Multiple regression: y = β₀ + β₁x₁ + β₂x₂ + ... + ε

from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error
import numpy as np

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Evaluation metrics
r2   = r2_score(y_test, y_pred)           # 0-1, higher better
mse  = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)                        # same units as y
mae  = np.mean(np.abs(y_test - y_pred))

print(f'R²: {r2:.3f}')
print(f'RMSE: {rmse:.3f}')
print(f'Coefficients: {model.coef_}')
print(f'Intercept: {model.intercept_}')

# Logistic regression (binary classification)
from sklearn.linear_model import LogisticRegression
log_model = LogisticRegression()
log_model.fit(X_train, y_train)
probs = log_model.predict_proba(X_test)[:, 1]  # prob of class 1

# Bayes' Theorem:
# P(A|B) = P(B|A) × P(A) / P(B)
#
# In modelling:
# Posterior = Likelihood × Prior / Evidence
# P(θ|data) ∝ P(data|θ) × P(θ)
#
# θ = parameter(s)
# Prior P(θ): belief about parameters BEFORE seeing data
# Likelihood P(data|θ): how likely data given parameters
# Posterior P(θ|data): updated belief AFTER seeing data

# Example: Coin flip
# Prior: P(θ=fair) = 0.5 (assume fair to start)
# Observe: 8 heads out of 10 flips
# Update: posterior shifts toward θ > 0.5

# Key differences from Frequentist:
# Bayesian: parameters have distributions, not fixed values
# Frequentist: parameters fixed, data is random

# Credible interval vs Confidence interval:
# Credible: P(θ in [a,b] | data) = 95%  ← direct probability!
# Confidence: If repeated, 95% of intervals contain true θ

from scipy import stats

# One-sample t-test
t_stat, p_val = stats.ttest_1samp(data, popmean=10)

# Two-sample t-test
t_stat, p_val = stats.ttest_ind(group1, group2)

# Paired t-test
t_stat, p_val = stats.ttest_rel(before, after)

# Chi-square test of independence
chi2, p, dof, expected = stats.chi2_contingency(contingency_table)

# ANOVA
f_stat, p_val = stats.f_oneway(group1, group2, group3)

# Normality test
stat, p = stats.shapiro(data)  # p > 0.05: normal

# Correlation
r, p = stats.pearsonr(x, y)
rho, p = stats.spearmanr(x, y)

import numpy as np
import pandas as pd
from scipy import stats
import statsmodels.api as sm

# Descriptive stats
df['salary'].describe()  # count,mean,std,min,quartiles,max
np.percentile(data, [25, 50, 75])
stats.kurtosis(data)     # peakedness
stats.skew(data)         # asymmetry

# OLS Regression with statsmodels
X = sm.add_constant(X)   # add intercept
model = sm.OLS(y, X).fit()
print(model.summary())    # full regression table

# Bootstrap confidence interval
def bootstrap_ci(data, n_boot=1000, ci=95):
    boot_means = [np.mean(np.random.choice(data, len(data), replace=True))
                  for _ in range(n_boot)]
    lo = (100-ci)/2
    return np.percentile(boot_means, [lo, 100-lo])

# Power analysis
from statsmodels.stats.power import TTestPower
analysis = TTestPower()
power = analysis.power(effect_size=0.5, nobs=30, alpha=0.05)
# Or: find required sample size
n = analysis.solve_power(effect_size=0.5, power=0.8, alpha=0.05)