[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_26":27,"_28":29,"_30":12,"_31":12,"_32":12,"_33":12,"_34":12,"_35":12,"_36":-5,"_37":38},"routes/canvas.shared.$sharedTextdocId",{"_9":10,"_11":12},"sharedTextdoc",{"_13":14,"_15":-7,"_16":17,"_18":19,"_20":21,"_22":23,"_24":12,"_25":12},"isAuthenticated",false,"sharedTextdocId","6898960d7d3c819187e22ad2c416ebde","versionInt","title","Ols Intuition Playground — Tutorial 2","type","code/react","content","import React, { useMemo, useRef, useState, useEffect, useCallback } from \"react\";\nimport { Card, CardContent, CardHeader, CardTitle } from \"@/components/ui/card\";\nimport { Button } from \"@/components/ui/button\";\nimport { Slider } from \"@/components/ui/slider\";\nimport { Switch } from \"@/components/ui/switch\";\nimport { Label } from \"@/components/ui/label\";\nimport { Alert, AlertDescription, AlertTitle } from \"@/components/ui/alert\";\nimport { Info } from \"lucide-react\";\n\n/**\n * OLS Basics — Bachelor-friendly interactive page\n *\n * Goals\n * 1) Show where OLS comes from (minimising SSE) with a single line y = a + b x\n * 2) Visualise core assumptions and what breaks when you violate them\n * 3) Build intuition for Standard Errors and R² — and how to make SE smaller\n */\n\n// ---------- helpers ----------\nfunction randn() { // Box–Muller\n let u = 0, v = 0;\n while (u === 0) u = Math.random();\n while (v === 0) v = Math.random();\n return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);\n}\n\nfunction mean(arr) { return arr.reduce((a, b) => a + b, 0) / Math.max(arr.length, 1); }\n\nfunction standardize(arr) {\n const m = mean(arr);\n const s = Math.sqrt(arr.reduce((acc, x) => acc + (x - m) ** 2, 0) / Math.max(arr.length - 1, 1)) || 1;\n return arr.map(x => (x - m) / s);\n}\n\nfunction linspace(min, max, n) { return Array.from({ length: n }, (_, i) => min + (i * (max - min)) / (n - 1)); }\n\nfunction corr(a, b) {\n const ma = mean(a), mb = mean(b);\n let num = 0, da = 0, db = 0;\n for (let i = 0; i < a.length; i++) {\n const xa = a[i] - ma, xb = b[i] - mb;\n num += xa * xb; da += xa * xa; db += xb * xb;\n }\n return num / Math.sqrt(Math.max(da * db, 1e-12));\n}\n\n// Small matrix helpers (2x2 / 3x3 only)\nfunction transpose(M) { return M[0].map((_, j) => M.map(row => row[j])); }\nfunction matMul(A, B) {\n const Bcols = Array.isArray(B[0]) ? B[0].length : 1;\n const Bmat = Array.isArray(B[0]) ? B : B.map(v => [v]);\n const res = Array.from({ length: A.length }, () => Array(Bcols).fill(0));\n for (let i = 0; i < A.length; i++) {\n for (let k = 0; k < A[0].length; k++) {\n for (let j = 0; j < Bcols; j++) {\n res[i][j] += A[i][k] * Bmat[k][j];\n }\n }\n }\n return res;\n}\nfunction invert2(M) {\n const [[a,b],[c,d]] = M; const det = a*d - b*c || 1e-12; return [[ d/det, -b/det],[-c/det, a/det]];\n}\nfunction invert3(M) {\n const [[a,b,c],[d,e,f],[g,h,i]] = M;\n const A = (e*i - f*h);\n const B = -(d*i - f*g);\n const C = (d*h - e*g);\n const D = -(b*i - c*h);\n const E = (a*i - c*g);\n const F = -(a*h - b*g);\n const G = (b*f - c*e);\n const H = -(a*f - c*d);\n const I = (a*e - b*d);\n const det = a*A + b*B + c*C || 1e-12;\n const cof = [[A,D,G],[B,E,H],[C,F,I]]; // cofactor matrix\n const adj = transpose(cof);\n return adj.map(row => row.map(v => v / det));\n}\nfunction quadForm(A, v) { // v' A v\n let s = 0; for (let i=0;i[1, x, Z[i]]) : X.map(x=>[1, x]);\n // build sums for XtX and XtY\n const XtX = Array.from({length:p},()=>Array(p).fill(0));\n const XtY = Array(p).fill(0);\n for (let i=0;ir[0]); // [a, bX, (bZ)]\n const a = beta[0]; const bX = beta[1]; const bZ = includeZ ? beta[2] : 0;\n const yhat = X.map((x,i)=> a + bX*x + (includeZ? bZ*Z[i] : 0));\n const e = Y.map((yi,i)=> yi - yhat[i]);\n const SSE = e.reduce((s,v)=>s+v*v,0);\n const ybar = mean(Y);\n const SST = Y.reduce((s,yi)=>s+(yi-ybar)**2,0);\n const SSR = SST - SSE;\n const df = Math.max(n - p, 1);\n const s2 = SSE/df;\n const seCov = inv.map(row=>row.map(v=>v*s2));\n const SEa = Math.sqrt(Math.max(seCov[0][0],0));\n const SEb = Math.sqrt(Math.max(seCov[1][1],0));\n const SEbZ = includeZ ? Math.sqrt(Math.max(seCov[2][2],0)) : 0;\n const xbar = mean(X); const Sxx = X.reduce((s,xi)=>s+(xi-xbar)**2,0);\n const R2 = SST===0 ? 1 : SSR/SST;\n return { a, b: bX, bZ, yhat, e, SSE, SSR, SST, R2, SEb, SEa, SEbZ, s2, xbar, ybar, Sxx, invXtX: inv, p };\n}\n\n// Robust (White/HC0) covariance for general design\nfunction robustSE_HC0_design(design, e) {\n const n = design.length; const p = design[0].length;\n const Xt = transpose(design);\n const XtX = matMul(Xt, design);\n const inv = (p===2) ? invert2(XtX) : invert3(XtX);\n const meat = Array.from({length:p},()=>Array(p).fill(0));\n for (let i=0;i {\n const n = x.length; const xbar = mean(x); const ybar = mean(y);\n const Sxx = x.reduce((s, xi) => s + (xi - xbar) ** 2, 0);\n const Sxy = x.reduce((s, xi, i) => s + (xi - xbar) * (y[i] - ybar), 0);\n const b = Sxx === 0 ? 0 : Sxy / Sxx; const a = ybar - b * xbar;\n const yhat = x.map(xi => a + b * xi); const e = y.map((yi, i) => yi - yhat[i]);\n return { a, b, yhat, e };\n };\n let { a, b, yhat, e } = olsSimple(x, y);\n const n = x.length;\n const median = (arr) => { const s = [...arr].sort((A,B)=>A-B); const m = Math.floor((s.length-1)/2); return s.length % 2 ? s[m] : 0.5*(s[m]+s[m+1]); };\n let mad = median(e.map(v => Math.abs(v))) || 1e-6;\n let s = 1.4826 * mad; if (!isFinite(s) || s <= 0) s = Math.sqrt(e.reduce((S,v)=>S+v*v,0) / Math.max(n-2,1));\n const cH = 1.345, cT = 4.685; const c = method === \"tukey\" ? (k || cT) : (k || cH);\n\n for (let it = 0; it < maxIter; it++) {\n const u = e.map(v => v / (c * s || 1e-12));\n const w = u.map(ui => {\n const aui = Math.abs(ui);\n if (method === \"tukey\") { if (aui >= 1) return 0; const t = 1 - ui*ui; return t*t; }\n else { return aui <= 1 ? 1 : 1/aui; }\n });\n const sumw = w.reduce((S,v)=>S+v,0) || 1e-12;\n const xbar_w = x.reduce((S,xi,i)=>S + w[i]*xi, 0) / sumw;\n const ybar_w = y.reduce((S,yi,i)=>S + w[i]*yi, 0) / sumw;\n const Sxxw = x.reduce((S,xi,i)=>S + w[i]*(xi-xbar_w)*(xi-xbar_w), 0) || 1e-12;\n const Sxyw = x.reduce((S,xi,i)=>S + w[i]*(xi-xbar_w)*(y[i]-ybar_w), 0);\n const bNew = Sxyw / Sxxw; const aNew = ybar_w - bNew * xbar_w;\n const yhatNew = x.map(xi => aNew + bNew * xi); const eNew = y.map((yi,i) => yi - yhatNew[i]);\n const delta = Math.abs(bNew - b) + Math.abs(aNew - a);\n a = aNew; b = bNew; yhat = yhatNew; e = eNew; if (delta < tol) break;\n }\n return { a, b, yhat, e };\n}\n\n// ---------- main component ----------\nexport default function OLSBasics() {\n // True DGP controls (kept simple)\n const [n, setN] = useState(60);\n const [beta0, setBeta0] = useState(1.0);\n const [beta1, setBeta1] = useState(0.7);\n const [beta2, setBeta2] = useState(0.0); // effect of Z (for omitted-variable intuition)\n const [xSpread, setXSpread] = useState(5); // controls Var(X)\n const [noiseSd, setNoiseSd] = useState(1.0);\n const [hetero, setHetero] = useState(0.0); // 0 = homoskedastic, >0 = fanning\n const [rhoEX, setRhoEX] = useState(0.0); // Corr(error, X) — exogeneity violation\n const [withOutlier, setWithOutlier] = useState(false);\n const [outlierType, setOutlierType] = useState(\"highX\"); // \"highX\" | \"lowX\" | \"vertical\"\n\n // Robust regression toggle (simple only)\n const [showRobust, setShowRobust] = useState(false);\n const [robustMethod, setRobustMethod] = useState(\"huber\"); // \"huber\" | \"tukey\"\n\n // Control variable lab\n const [includeZ, setIncludeZ] = useState(false); // when ON, OLS includes Z\n const [corrXZ, setCorrXZ] = useState(0.0); // link between X and Z (drives OVB if Z omitted)\n\n // Residual plot controls\n const [resPlotMode, setResPlotMode] = useState(\"fitted\"); // 'fitted' | 'x' | 'z'\n const [resStandardize, setResStandardize] = useState(false);\n\n // --- Generate base data (no outlier) once per state ---\n const baseData = useMemo(() => {\n const xs = Array.from({ length: n }, () => (Math.random() * 2 - 1) * xSpread);\n const xStd = standardize(xs);\n // Z correlated with X by corrXZ\n const zNoise = Array.from({ length: n }, () => randn());\n const zStd = xStd.map((xi, i) => corrXZ * xi + Math.sqrt(Math.max(1 - corrXZ ** 2, 0)) * zNoise[i]);\n const Z = zStd.map(z => z);\n // Error\n const u = Array.from({ length: n }, () => randn());\n const eps = u.map((ui, i) => {\n const scale = noiseSd * (1 + hetero * Math.abs(xStd[i]));\n return scale * (Math.sqrt(Math.max(1 - rhoEX ** 2, 0)) * ui + rhoEX * xStd[i]);\n });\n const Y = xs.map((x, i) => beta0 + beta1 * x + beta2 * Z[i] + eps[i]);\n return { X: xs, Z, Y };\n }, [n, beta0, beta1, beta2, xSpread, noiseSd, hetero, rhoEX, corrXZ]);\n\n // Outlier version derived deterministically from base — supports multiple types\n const outlierData = useMemo(() => {\n const X = [...baseData.X];\n const Z = [...baseData.Z];\n const Y = [...baseData.Y];\n if (outlierType === \"highX\") {\n X[0] = xSpread * 3; // leverage right\n Y[0] = beta0 + beta1 * X[0] + beta2 * (Z[0] || 0) + (5 * noiseSd);\n } else if (outlierType === \"lowX\") {\n X[0] = -xSpread * 3; // leverage left\n Y[0] = beta0 + beta1 * X[0] + beta2 * (Z[0] || 0) - (5 * noiseSd);\n } else { // vertical outlier: big residual near mean X\n const xbar = mean(X);\n let idx = 0; let best = Infinity;\n for (let i = 0; i < X.length; i++) {\n const d = Math.abs(X[i] - xbar);\n if (d < best) { best = d; idx = i; }\n }\n Y[idx] = Y[idx] + 8 * noiseSd; // large vertical deviation\n }\n return { X, Z, Y };\n }, [baseData, outlierType, xSpread, beta0, beta1, beta2, noiseSd]);\n\n // Choose which dataset to display\n const data = withOutlier ? outlierData : baseData;\n const altData = withOutlier ? baseData : outlierData; // the other scenario for overlay comparison\n\n // Current/alternate fits (simple or with Z)\n const fit = useMemo(() => olsFlex(data.X, data.Z, data.Y, includeZ), [data, includeZ]);\n const fitAlt = useMemo(() => olsFlex(altData.X, altData.Z, altData.Y, includeZ), [altData, includeZ]);\n\n // Robust SEs for slope on X (HC0)\n const design = useMemo(() => (includeZ ? data.X.map((x,i)=>[1,x,data.Z[i]]) : data.X.map(x=>[1,x])), [data, includeZ]);\n const covHC = useMemo(() => robustSE_HC0_design(design, fit.e), [design, fit.e]);\n const SEbHC = Math.sqrt(Math.max(covHC[1][1], 0));\n\n // R² bars\n const r2Pct = Math.max(0, Math.min(1, fit.R2));\n\n // Assumption checks\n const checks = useMemo(() => {\n const homoskedastic = hetero === 0;\n const exogeneity = Math.abs(rhoEX) < 1e-6; // Corr(e,X)=0\n const linear = true; // by construction\n const largeN = n >= 30;\n const noPerfectCollinearity = Math.abs(corrXZ) < 0.98; // guidance for the Z lab\n return { homoskedastic, exogeneity, linear, largeN, noPerfectCollinearity };\n }, [hetero, rhoEX, n, corrXZ]);\n\n // UI sizing helpers\n const chartWidth = 760, chartHeight = 420; // main chart\n const resWidth = 760, resHeight = 260; // residual chart\n const margin = { top: 20, right: 18, bottom: 44, left: 56 };\n const innerW = chartWidth - margin.left - margin.right;\n const innerH = chartHeight - margin.top - margin.bottom;\n\n // Scales for main chart\n const xMin = Math.min(...data.X), xMax = Math.max(...data.X);\n const yMin = Math.min(\n ...data.Y,\n ...fit.yhat,\n withOutlier ? Math.min(...fitAlt.yhat) : Infinity\n );\n const yMax = Math.max(\n ...data.Y,\n ...fit.yhat,\n withOutlier ? Math.max(...fitAlt.yhat) : -Infinity\n );\n const xToPx = (x) => margin.left + ((x - xMin) / (xMax - xMin || 1)) * innerW;\n const yToPx = (y) => margin.top + innerH - ((y - yMin) / (yMax - yMin || 1)) * innerH;\n\n // CI for fitted line (current data) — if Include Z, hold Z at mean for the line drawing\n const tStar = 1.96;\n const zbar = useMemo(()=> mean(data.Z || Array(data.X.length).fill(0)), [data.Z, data.X.length]);\n const ciLine = useMemo(() => {\n const xs = linspace(xMin, xMax, 40);\n if (!includeZ) {\n const nObs = data.X.length; const xbar = fit.xbar; const Sxx = Math.max(fit.Sxx, 1e-12);\n return xs.map(x => {\n const yhat = fit.a + fit.b * x;\n const seFit = Math.sqrt(fit.s2 * (1 / nObs + ((x - xbar) ** 2) / Sxx));\n return { x, yLow: yhat - tStar * seFit, yHigh: yhat + tStar * seFit, yhat };\n });\n } else {\n return xs.map(x => {\n const yhat = fit.a + fit.b * x + (fit.bZ||0) * zbar;\n const xvec = [1, x, zbar];\n const seFit = Math.sqrt(Math.max(fit.s2 * quadForm(fit.invXtX, xvec), 0));\n return { x, yLow: yhat - tStar * seFit, yHigh: yhat + tStar * seFit, yhat };\n });\n }\n }, [includeZ, data.X.length, fit.a, fit.b, fit.bZ, fit.s2, fit.invXtX, fit.xbar, fit.Sxx, xMin, xMax, zbar]);\n\n // Quick actions to lower SE(b_X)\n const tweak = {\n moreData: () => setN(n => Math.min(n + 40, 500)),\n spreadX: () => setXSpread(s => Math.min(s + 2, 12)),\n cleaner: () => setNoiseSd(sd => Math.max(0, sd - 0.3)),\n addZ: () => { setBeta2(b => Math.max(b, 0.6)); setIncludeZ(true); },\n };\n\n // Consequences\n const bias_b = fit.b - beta1; // relative to true β1*\n const seRatio = SEbHC / (fit.SEb || 1e-12);\n const outlierDeltaB = fitAlt.b - fit.b; // difference with/without outlier\n const outlierDeltaA = fitAlt.a - fit.a;\n const r2Delta = fitAlt.R2 - fit.R2;\n\n // --------- The \"process\" of OLS (animated gradient descent; simple X-only) ---------\n const [aProc, setAProc] = useState(0);\n const [bProc, setBProc] = useState(0);\n const [procPlay, setProcPlay] = useState(false);\n const [procLR, setProcLR] = useState(0.2); // learning rate (scaled)\n const [procSpeed, setProcSpeed] = useState(30); // ms per step\n const [procPath, setProcPath] = useState([]); // trail of (a,b)\n const stepTimer = useRef(null);\n\n // reset process when data/model changes\n useEffect(() => { setAProc(0); setBProc(0); setProcPlay(false); setProcPath([]); }, [data, withOutlier, outlierType, includeZ]);\n\n const procStats = useMemo(() => {\n const e = data.Y.map((yi, i) => yi - (aProc + bProc * data.X[i]));\n const SSE = e.reduce((s, v) => s + v * v, 0);\n const sumE = e.reduce((s, v) => s + v, 0);\n const sumXE = e.reduce((s, v, i) => s + v * data.X[i], 0);\n return { SSE, sumE, sumXE };\n }, [aProc, bProc, data]);\n\n const procStep = useCallback(() => {\n const nObs = data.X.length; const Sxx = Math.max(fit.Sxx, 1e-12); const { sumE, sumXE } = procStats;\n const gA = -2 * sumE; const gB = -2 * sumXE;\n const aNext = aProc - (procLR / Math.max(nObs, 1)) * gA;\n const bNext = bProc - (procLR / Math.max(Sxx, 1e-12)) * gB;\n setAProc(aNext); setBProc(bNext);\n setProcPath((path) => { const np = [...path, { a: aNext, b: bNext }]; return np.length > 60 ? np.slice(np.length - 60) : np; });\n if (Math.abs(aNext - fit.a) + Math.abs(bNext - fit.b) < 1e-4) setProcPlay(false);\n }, [aProc, bProc, procLR, data.X.length, fit.Sxx, procStats, fit.a, fit.b]);\n\n useEffect(() => {\n if (procPlay) {\n if (stepTimer.current) clearInterval(stepTimer.current);\n stepTimer.current = setInterval(procStep, Math.max(10, procSpeed));\n return () => clearInterval(stepTimer.current);\n } else { if (stepTimer.current) { clearInterval(stepTimer.current); stepTimer.current = null; } }\n }, [procPlay, procSpeed, procStep]);\n\n const resetDefaults = () => {\n setN(60); setBeta0(1.0); setBeta1(0.7); setBeta2(0.0); setXSpread(5); setNoiseSd(1.0);\n setHetero(0); setRhoEX(0); setWithOutlier(false); setShowRobust(false); setIncludeZ(false); setCorrXZ(0);\n setOutlierType(\"highX\"); setResPlotMode(\"fitted\"); setResStandardize(false);\n };\n\n // ---------- Residual diagnostics helpers ----------\n const hatDiag = useMemo(() => {\n return data.X.map((x,i) => {\n const xi = includeZ ? [1, x, data.Z[i]] : [1, x];\n return quadForm(fit.invXtX, xi);\n });\n }, [data, includeZ, fit.invXtX]);\n\n const studentRes = useMemo(() => fit.e.map((ei,i) => ei / Math.sqrt(Math.max(fit.s2 * (1 - hatDiag[i]), 1e-8))), [fit.e, fit.s2, hatDiag]);\n const resY = resStandardize ? studentRes : fit.e;\n const resX = resPlotMode === 'fitted' ? fit.yhat : (resPlotMode === 'x' ? data.X : data.Z);\n const rXmin = Math.min(...resX), rXmax = Math.max(...resX);\n const rYmin = Math.min(...resY, resStandardize ? -3.2 : -3* Math.sqrt(fit.s2));\n const rYmax = Math.max(...resY, resStandardize ? 3.2 : 3* Math.sqrt(fit.s2));\n const rxToPx = (x) => margin.left + ((x - rXmin) / (rXmax - rXmin || 1)) * (resWidth - margin.left - margin.right);\n const ryToPx = (y) => margin.top + (resHeight - margin.top - margin.bottom) - ((y - rYmin) / (rYmax - rYmin || 1)) * (resHeight - margin.top - margin.bottom);\n\n const absCorr = useMemo(() => corr(resY.map(v=>Math.abs(v)), (resPlotMode==='x'? data.X : fit.yhat).map(v=>Math.abs(v))), [resY, resPlotMode, data.X, fit.yhat]);\n\n const residSD = Math.sqrt(fit.s2);\n const seLink = Math.sqrt(Math.max(fit.s2 * fit.invXtX[1][1], 0)); // matches fit.SEb\n\n // UI pieces for legend moved to RIGHT PANEL (not on chart)\n const LegendItem = ({ color, dash, label }) => (\n

\n \n {label}\n

\n );\n\n return (\n

OLS Basics — Interactive Intuition

Watch OLS find the line: residuals shrink, SSE falls, and the normal-equation conditions approach zero.

\n \n

\n\n {/* Data generator & assumption toggles */}\n \n Step 1 — Create a simple world\n \n

\n Observations: {n}\n setN(v[0])} />\n

\n True slope β₁*: {beta1.toFixed(2)}\n setBeta1(v[0])} />\n

\n True intercept β₀*: {beta0.toFixed(2)}\n setBeta0(v[0])} />\n

\n Spread of X (Var(X)): {xSpread.toFixed(1)}\n setXSpread(v[0])} />\n

\n Noise SD (σ): {noiseSd.toFixed(2)}\n setNoiseSd(v[0])} />\n

\n \n Outlier mode (compare fits)\n {withOutlier && (\n

\n Type:\n \n \n \n

\n )}\n

\n Heteroskedasticity (fan shape): {hetero.toFixed(2)}\n setHetero(v[0])} />\n

\n Corr(error, X) — exogeneity: {rhoEX.toFixed(2)}\n setRhoEX(v[0])} />\n

Include relevant control Z (estimation)

\n Effect of Z in DGP (β₂*): {beta2.toFixed(2)}\n setBeta2(v[0])} />\n Corr(X, Z) in DGP: {corrXZ.toFixed(2)}\n setCorrXZ(v[0])} />\n

\n {!includeZ && (\n

\n \n Show robust line\n {showRobust && (\n

\n Method:\n \n \n

\n )}\n

\n )}\n \n \n\n {/* Scatter + fit + right-side legend (off-chart) */}\n \n Step 2 — Fit by least squares (minimise SSE)\n \n

\n {/* Chart */}\n \n\n {/* Right legend + description (kept off the chart for clarity) */}\n

Lines shown

\n \n {withOutlier && }\n {!includeZ && showRobust && }\n {!includeZ && }\n

\n {includeZ && (\n

\n The plotted blue line fixes Z at its mean: \n ŷ = â + b̂_X·x + b̂_Z·ȳ_Z. Predictions per point still use each point's own Zᵢ.\n

\n )}\n

\n\n {/* summary cards under the chart */}\n

OLS estimates (current)

\n {!includeZ ? (\n

â = {fit.a.toFixed(3)} b̂ = {fit.b.toFixed(3)}

\n ) : (\n

â = {fit.a.toFixed(3)} b̂_X = {fit.b.toFixed(3)} b̂_Z = {(fit.bZ||0).toFixed(3)}

\n )}\n

Rule: choose parameters to make SSE = Σe² as small as possible.

Standard Errors (current)

OLS: s.e.(b̂_X) = {fit.SEb.toFixed(3)} | HC: {SEbHC.toFixed(3)}

s.e.(b̂_X)=√(σ̂²·[(X'X)⁻¹]₂₂). σ̂ is the residual SD below.

Fit quality

R² = {fit.R2.toFixed(3)}

R² is the % of Y-variation explained by the model.

\n \n \n\n {/* The process of OLS (only for simple X-only view) */}\n {!includeZ && (\n \n Step 2.5 — Watch OLS solve itself\n \n

Controls

\n \n \n \n \n \n

\n Learning rate (step size): {procLR.toFixed(2)}\n setProcLR(v[0])} />\n Animation speed (ms per step): {procSpeed}\n setProcSpeed(v[0])} />\n

SSE falling

SSE(process) vs SSE(OLS)

SSE(process) = {procStats.SSE.toFixed(2)} | SSE(OLS) = {fit.SSE.toFixed(2)}

Normal equations (target = 0)

Σe = {procStats.sumE.toFixed(3)} {Math.abs(procStats.sumE) < 1e-2 ? '✅' : '⬜'}

Σx·e = {procStats.sumXE.toFixed(3)} {Math.abs(procStats.sumXE) < 1e-2 ? '✅' : '⬜'}

When both are ~0, the green line has reached the least‑squares solution.

\n \n \n )}\n\n {/* NEW: Residuals — visualize σ and assumptions */}\n \n Step 2.6 — Residuals: see σ̂ and assumptions\n \n

\n {/* Residual plot */}\n \n\n {/* Right controls + interpretation */}\n

What you're seeing

σ̂ (residual SD) summarises vertical scatter. The slope's s.e. obeys s.e.(b̂_X)=√(σ̂²·[(X'X)⁻¹]₂₂). Reduce σ̂, increase spread of X, or increase n to shrink s.e.

\n \n \n {includeZ && }\n

\n \n Standardize residuals\n

\n\n

σ̂ (residual SD) = {residSD.toFixed(3)}

s.e.(b̂_X) = {fit.SEb.toFixed(3)} (HC: {SEbHC.toFixed(3)})

|residual| vs {resPlotMode==='x'?'X':'Fitted'} corr ≈ {absCorr.toFixed(2)} {Math.abs(absCorr)>0.3 && '(fan shape likely)'}

Hints: fan shape ⇒ heteroskedasticity; curve ⇒ nonlinearity; stripes/outliers ⇒ influential points.

\n\n

Shrink scatter quickly

\n \n \n \n {Math.abs(beta2) < 1e-6 ? (\n \n ) : (\n Z already affects Y (β₂={beta2.toFixed(2)})\n )}\n

\n \n \n\n {/* R2 and variance decomposition */}\n \n Step 3 — Variance decomposition (why R² moves)\n \n

Blue bar = explained variation (SSR). Grey remainder = unexplained (SSE). R² = SSR/SST.

SST = {fit.SST.toFixed(2)}

SSR = {fit.SSR.toFixed(2)}

SSE = {fit.SSE.toFixed(2)}

s² = {fit.s2.toFixed(3)}

\n \n \n\n {/* Assumptions visual checklist + CONSEQUENCES */}\n \n Step 4 — Assumptions & consequences\n \n

Linearity ✓

We fit a straight line: y = a + b x{includeZ?\" + c z\":\"\"}.

Consequence if false: model misspecification → biased/inefficient estimates; patterns in residuals.

Exogeneity {checks.exogeneity ? \"✓\" : \"✗\"}

E[ε|X] = 0.

Consequence: bias. Current b̂_X − β₁* = {bias_b.toFixed(3)}.

Homoskedasticity {checks.homoskedastic ? \"✓\" : \"✗\"}

Equal variance of errors.

Consequence: wrong s.e. OLS/HC ratio = {(1/seRatio).toFixed(2)} (HC/OLS = {seRatio.toFixed(2)}).

Large sample {checks.largeN ? \"✓\" : \"(n<30)\"}

With enough n, estimates and t-stats behave well.

Current t_X ≈ {(fit.b/(fit.SEb||1e-12)).toFixed(2)}.

No (near) multicollinearity {checks.noPerfectCollinearity ? \"✓\" : \"✗\"}

If Corr(X,Z) ≈ ±1, s.e. explode and estimates become unstable.

\n {withOutlier && (\n

Outlier influence (ON)

Slope change Δb_X = {outlierDeltaB.toFixed(3)}, Intercept change Δa = {outlierDeltaA.toFixed(3)}, ΔR² = {r2Delta.toFixed(3)}.

Consequence: high‑leverage points can pull the line; consider diagnostics or robust methods.

\n )}\n \n \n\n {/* OVB box when Z exists but is OMITTED in estimation */}\n {!includeZ && Math.abs(beta2) > 1e-6 && (\n \n Omitted Variable Bias (when you don’t include Z)\n \n True model has Z with β₂ = {beta2.toFixed(2)} and Corr(X,Z) = {corrXZ.toFixed(2)}.\n If you regress Y on X only, the slope is biased by ≈ β₂ · Cov(X,Z)/Var(X).\n \n \n )}\n\n {/* Derivation (very light) */}\n \n Derivation sketch (no pain version)\n \n

We choose parameters to minimise SSE(a,b[,c]) = Σ( yᵢ − (a + b xᵢ {includeZ?\"+ c zᵢ\":\"\"}) )².

Set partial derivatives to zero ⇒ the normal equations and solve for coefficients.

For simple regression: b̂ = Cov(X,Y)/Var(X) and â = ȳ − b̂ x̄.

That’s it — OLS is the line with the smallest total squared residuals.

\n \n \n

\n );\n}\n","access","public","isModerationBlocked","isAnonifyApiKeyDetected","dd",{"_39":40,"_41":42},"disablePrefetch",true,"shouldPrefetchAccount","shouldPrefetchUser","shouldPrefetchSystemHints","promoteCss","disableSSR","stripModulepreloadImports","paidCampaignAppRedirect","statsigGateEvaluationsPromise",["P",38],"traceId","12459471093320929507","traceTime",1785533464536]