A distribuição normal

O vídeo abaixo mostra um exemplo de um tabuleiro de Galton (também conhecido como Quincunx), que demonstra como a distribuição normal surge da soma de muitas variáveis aleatórias independentes.

Este vídeo demonstra um dispositivo conhecido como tabuleiro de Galton (também chamado de quincunx). É um instrumento que permite visualizar conceitos estatísticos abstractos.

Aqui está uma análise do que está a acontecer:

• A Configuração: O dispositivo contém milhares de pequenas esferas de aço. Quando o tabuleiro é virado, as esferas descem através de um funil no topo e caem em cascata através de fileiras de pinos dispostos num padrão hexagonal.
• O “Passeio Aleatório”: À medida que cada esfera atinge um pino, tem uma probabilidade de aproximadamente 50/50 de saltar para a esquerda ou para a direita. Isto acontece repetidamente à medida que a esfera cai através de várias filas de pinos.
• O Resultado: Embora o caminho de qualquer esfera individual seja aleatório e imprevisível, o resultado de milhares de esferas a cair é matematicamente previsível. Para acabar nos compartimentos da extrema esquerda ou extrema direita, uma esfera teria de saltar na mesma direcção quase todas as vezes (por exemplo, Esquerda-Esquerda-Esquerda-Esquerda), o que é estatisticamente raro. É muito mais provável que uma esfera salte para a esquerda e para a direita aproximadamente um número igual de vezes, fazendo com que caia nos compartimentos centrais.
• A Curva em Sino: À medida que as esferas se acumulam no fundo, formam uma forma conhecida como Distribuição Normal (ou Curva em Sino).

Esta máquina, inventada por Sir Francis Galton no século XIX, é uma demonstração física perfeita do Teorema do Limite Central. Mostra como a soma de muitas variáveis aleatórias independentes (os saltos esquerda/direita) tende a produzir uma distribuição normal, independentemente da distribuição original das variáveis.

Simular um tabuleiro de Galton

Utilize a simulação interactiva abaixo para experimentar o Teorema do Limite Central e o conceito de Deriva (Drift).

• Número de bolas: Controla o tamanho da amostra. Isto demonstra a Lei dos Grandes Números: à medida que o número de ensaios aumenta, a distribuição empírica converge para a distribuição teórica. (Nota: A curva vermelha representa a distribuição padrão não enviesada (\(p=0.5\)) para referência; alterar o viés deslocará os resultados para longe desta curva).
• Viés: Controla uma deriva lateral, análoga a alterar a probabilidade de saltar para a direita em cada pino.
  • 50% de Viés: Representa um passeio aleatório padrão onde \(p=0.5\). A distribuição centra-se no meio.
  • > 50% de Viés: Análogo a um activo com um retorno esperado positivo (deriva positiva). A distribuição desloca-se para a direita.
  • < 50% de Viés: Análogo a uma deriva negativa. A distribuição desloca-se para a esquerda.

Matter = require("https://cdn.jsdelivr.net/npm/[email protected]/build/matter.min.js");

viewof ballCount = Inputs.range([100, 800], {
  step: 50,
  value: 600,
  label: "Número de bolas"
});

viewof biasPct = Inputs.range([45, 55], {
  step: 1,
  value: 50,
  label: "Viés (0% = tudo à esq., 100% = tudo à dir.)"
});

viewof rerun = {
  const btn = html`<button style="
    background: #2f71d5;
    color: white;
    border: none;
    border-radius: 10px;
    padding: 0.55rem 1.3rem;
    font-weight: 600;
    cursor: pointer;
  ">Largar bolas</button>`;

  // Keep Observable-style reactive semantics by updating the value on each click.
  let clicks = 0;
  btn.value = clicks;
  btn.addEventListener("click", () => {
    btn.value = ++clicks;
    btn.dispatchEvent(new Event("input", { bubbles: true }));
  });

  return btn;
};

galtonBoard = {
  // Referencing these values makes the simulation reactive to slider updates or button clicks.
  const runId = rerun;
  const bias = biasPct / 100;

  const container = html`<div style="
    width: min(100%, 480px);
    aspect-ratio: 5 / 6;
    height: auto;
    min-height: 320px;
    margin: 0 auto;
    background: #f8fafc;
    border: 1px solid #e5e7eb;
    border-radius: 12px;
    box-shadow: 0 12px 28px rgba(15, 23, 42, 0.12);
    overflow: hidden;
  "></div>`;

  // Do not start dropping until the button is pressed.
  if (!runId) {
    container.style.display = "flex";
    container.style.alignItems = "center";
    container.style.justifyContent = "center";
    container.style.color = "#1f2937";
    container.style.fontWeight = "600";
    container.textContent = "Prima “Largar bolas” para iniciar a simulação.";
    return container;
  }

  const cleanup = setupGaltonBoard(container, { ballCount, bias });
  invalidation.then(() => cleanup());
  return container;
}

setupGaltonBoard = (container, { ballCount, bias }) => {
  const {
    Engine,
    Render,
    Runner,
    Composite,
    Bodies,
    Events,
  } = Matter;

  const WIDTH = 1000;
  const HEIGHT = 1200;
  const WALL_THICKNESS = 20;
  const PEG_ROWS = 21;
  const PEG_START_Y = 100;
  const PEG_SPACING_Y = 32;
  const PEG_SPACING_X = 35;
  const PEG_RADIUS = 3;
  const BALL_RADIUS = 4.5;
  const lastPegY = PEG_START_Y + (PEG_ROWS - 1) * PEG_SPACING_Y;
  const BIN_HEIGHT = HEIGHT - lastPegY;
  const DIVIDER_WIDTH = 4;

  container.innerHTML = "";

  const engine = Engine.create({
    enableSleeping: true,
    positionIterations: 15,
    velocityIterations: 15,
  });

  engine.gravity.x = (bias - 0.5) * 1.5;
  engine.gravity.y = 1;

  const render = Render.create({
    element: container,
    engine,
    options: {
      width: WIDTH,
      height: HEIGHT,
      wireframes: false,
      background: "#f3f4f6",
      pixelRatio: window.devicePixelRatio,
      showSleeping: false,
    },
  });

  // Make the canvas responsive to the container.
  render.canvas.style.width = "100%";
  render.canvas.style.height = "100%";

  const runner = Runner.create();
  const world = engine.world;
  const staticBodies = [];

  // Walls
  staticBodies.push(
    Bodies.rectangle(WIDTH / 2, HEIGHT + 50, WIDTH + 200, 100, {
      isStatic: true,
      render: { fillStyle: "#374151" },
    }),
    Bodies.rectangle(0 - WALL_THICKNESS / 2, HEIGHT / 2, WALL_THICKNESS, HEIGHT, {
      isStatic: true,
      render: { fillStyle: "#374151" },
    }),
    Bodies.rectangle(WIDTH + WALL_THICKNESS / 2, HEIGHT / 2, WALL_THICKNESS, HEIGHT, {
      isStatic: true,
      render: { fillStyle: "#374151" },
    })
  );

  // Funnel
  staticBodies.push(
    Bodies.rectangle(WIDTH / 2 - 60, 50, 120, 10, {
      isStatic: true,
      angle: Math.PI / 3,
      render: { fillStyle: "#4b5563" },
    }),
    Bodies.rectangle(WIDTH / 2 + 60, 50, 120, 10, {
      isStatic: true,
      angle: -Math.PI / 3,
      render: { fillStyle: "#4b5563" },
    })
  );

  // Pegs
  for (let row = 0; row < PEG_ROWS; row++) {
    const y = PEG_START_Y + row * PEG_SPACING_Y;
    const itemsInRow = row + 3;
    const halfWidth = ((itemsInRow - 1) * PEG_SPACING_X) / 2;
    const startX = WIDTH / 2 - halfWidth;

    for (let j = 0; j < itemsInRow; j++) {
      const x = startX + j * PEG_SPACING_X;
      staticBodies.push(
        Bodies.circle(x, y, PEG_RADIUS, {
          isStatic: true,
          render: { fillStyle: "#374151" },
          restitution: 0.5,
          friction: 0,
        })
      );
    }
  }

  // Bin dividers
  const lastRowItems = PEG_ROWS - 1 + 3;
  const lastRowHalfWidth = ((lastRowItems - 1) * PEG_SPACING_X) / 2;
  const lastRowStartX = WIDTH / 2 - lastRowHalfWidth;
  const binCenters = Array.from({ length: lastRowItems - 1 }, (_, i) => (
    lastRowStartX + PEG_SPACING_X * (i + 0.5)
  ));

  for (let j = 0; j < lastRowItems; j++) {
    const x = lastRowStartX + j * PEG_SPACING_X;
    const isEdge = j === 0 || j === lastRowItems - 1;
    const dividerHeight = isEdge ? HEIGHT - PEG_START_Y : BIN_HEIGHT;
    const dividerWidth = isEdge ? 24 : DIVIDER_WIDTH;
    staticBodies.push(
      Bodies.rectangle(x, HEIGHT - dividerHeight / 2, dividerWidth, dividerHeight, {
        isStatic: true,
        render: { fillStyle: "#374151" },
        friction: 0.1,
        restitution: 0.1,
      })
    );
  }

  Composite.add(world, staticBodies);

  Render.run(render);
  Runner.run(runner, engine);

  // Pre-compute a normal curve to overlay on the bins so users can compare the shape.
  const trials = PEG_ROWS;
  const p = 0.5; // Keep the reference curve unbiased regardless of slider bias.
  const mean = trials * p;
  const stdDev = Math.sqrt(trials * p * (1 - p));
  const erf = (x) => {
    const sign = Math.sign(x);
    const a1 = 0.254829592;
    const a2 = -0.284496736;
    const a3 = 1.421413741;
    const a4 = -1.453152027;
    const a5 = 1.061405429;
    const pVal = 0.3275911;
    const absX = Math.abs(x);
    const t = 1 / (1 + pVal * absX);
    const y = 1 - (((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t) * Math.exp(-absX * absX);
    return sign * y;
  };
  const normalCdf = (x) => 0.5 * (1 + erf((x - mean) / (stdDev * Math.SQRT2)));
  const binProbabilities = binCenters.map((_, i) => {
    const left = i - 0.5;
    const right = i + 0.5;
    return Math.max(0, normalCdf(right) - normalCdf(left));
  });
  const baseY = HEIGHT - 8;
  const maxCurveHeight = BIN_HEIGHT - 30;
  const expectedCounts = binProbabilities.map((prob) => prob * ballCount);
  const maxExpectedCount = Math.max(...expectedCounts, 1);
  const basePixelsPerBall = 1.5;
  const pixelsPerBall = Math.min(basePixelsPerBall, maxCurveHeight / maxExpectedCount);
  const normalCurvePoints = binCenters.map((x, i) => {
    const scaled = expectedCounts[i] * pixelsPerBall;
    return { x, y: baseY - scaled };
  });

  const drawNormalCurve = () => {
    const ctx = render.context;
    ctx.save();
    const gradient = ctx.createLinearGradient(0, baseY - maxCurveHeight, 0, baseY);
    gradient.addColorStop(0, "rgba(220, 38, 38, 0.85)");
    gradient.addColorStop(1, "rgba(220, 38, 38, 0.25)");
    ctx.strokeStyle = gradient;
    ctx.lineWidth = 4;
    ctx.beginPath();
    normalCurvePoints.forEach(({ x, y }, index) => {
      if (index === 0) {
        ctx.moveTo(x, y);
      } else {
        ctx.lineTo(x, y);
      }
    });
    ctx.stroke();
    ctx.restore();
  };

  Events.on(render, "afterRender", drawNormalCurve);

  let ballsCreated = 0;
  const interval = setInterval(() => {
    if (ballsCreated >= ballCount) {
      clearInterval(interval);
      return;
    }

    const randomOffset = (Math.random() - 0.5) * 10;
    const ball = Bodies.circle(WIDTH / 2 + randomOffset, -20, BALL_RADIUS, {
      restitution: 0.5,
      friction: 0.001,
      frictionAir: 0.04,
      sleepThreshold: 30,
      density: 0.04,
      render: { fillStyle: "#3b82f6" },
    });

    Composite.add(engine.world, ball);
    ballsCreated += 1;
  }, 40);

  return () => {
    clearInterval(interval);
    Render.stop(render);
    Runner.stop(runner);
    Events.off(render, "afterRender", drawNormalCurve);
    Composite.clear(world, false, true);
    Engine.clear(engine);
    if (render.canvas) render.canvas.remove();
  };
};

Visualizar a densidade normal

Abaixo pode encontrar um gráfico de duas funções de densidade de uma distribuição Normal. A curva azul mostra a função de densidade de uma distribuição Normal padronizada (0, 1), enquanto a curva vermelha permite ajustar a média e o desvio padrão para ver como a forma muda.

A relação entre uma variável normal geral \(X\) e a variável normal padronizada \(Z\) é dada pela fórmula do Z-score: \[ Z = \frac{X - \mu}{\sigma} \]

Esta padronização permite-nos comparar diferentes distribuições normais e é fundamental para cálculos como o Value-at-Risk (VaR).

Altere esses parâmetros utilizando os controlos deslizantes abaixo e veja como isso afecta a função de densidade (área a vermelho).

Para mais informações sobre a distribuição Normal, consulte:

• Normal Distribution – from Wolfram MathWorld
  
• Probability density function (Wikipedia)

A densidade normal para \(X \sim \mathcal{N}(\mu, \sigma^2)\) é

\[ f_X(x) = \frac{1}{\sigma \sqrt{2\pi}}\exp\left(-\frac{(x-\mu)^2}{2\sigma^2}\right). \]

NoteContexto Financeiro: Retornos vs. Preços

Em finanças, assumimos frequentemente que os retornos logarítmicos (log-returns) de um activo são normalmente distribuídos: \[ \ln(S_t/S_{t-1}) \sim \mathcal{N}(\mu, \sigma^2) \] Isto implica que os preços dos activos seguem uma Distribuição Lognormal.

• Responsabilidade Limitada: Embora os retornos possam ser negativos, os preços dos activos não podem ser negativos. Esta é uma razão fundamental pela qual modelamos os preços como Lognormal (domínio \(0\) a \(\infty\)) em vez de Normal (domínio \(-\infty\) a \(\infty\)).

A Função de Distribuição Acumulada (CDF) da distribuição normal padrão, frequentemente denotada como \(N(x)\) ou \(\Phi(x)\), representa a probabilidade de uma variável assumir um valor menor ou igual a \(x\) (a área sob a curva à esquerda).

Crítica: Os dados financeiros do mundo real desviam-se frequentemente da normalidade:

• “Caudas Pesadas” (Excesso de Curtose): Eventos extremos (crashes ou booms) acontecem com mais frequência do que o previsto.
• Assimetria: Os mercados exibem frequentemente assimetria (por exemplo, os mercados accionistas têm frequentemente assimetria negativa, implicando maior risco de crash).

Plot = require("@observablehq/plot")
viewof mean = Inputs.range([-2, 2], { step: 0.1, label: "Média", value: 0 })
viewof sd = Inputs.range([0.1, 5], { step: 0.1, label: "Desvio padrão", value: 1 })

normalDensities = {
  // Expand the x-range as sd grows so wide curves aren’t clipped.
  const span = Math.max(6, 5 * sd);          // cover at least ±5σ of the wider dist
  const start = Math.min(-span, mean - span);
  const end = Math.max(span, mean + span);
  const steps = 1201;
  const step = (end - start) / (steps - 1);
  const x = Array.from({ length: steps }, (_, i) => start + i * step);

  // Error function approximation for CDF
  const erf = (x) => {
    const sign = Math.sign(x);
    const a1 = 0.254829592;
    const a2 = -0.284496736;
    const a3 = 1.421413741;
    const a4 = -1.453152027;
    const a5 = 1.061405429;
    const pVal = 0.3275911;
    const absX = Math.abs(x);
    const t = 1 / (1 + pVal * absX);
    const y = 1 - (((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t) * Math.exp(-absX * absX);
    return sign * y;
  };

  // PDF
  function dnorm(x, mu = 0, sigma = 1) {
    return (1 / (sigma * Math.sqrt(2 * Math.PI))) *
           Math.exp(-0.5 * Math.pow((x - mu) / sigma, 2));
  }

  // CDF
  function pnorm(x, mu = 0, sigma = 1) {
    return 0.5 * (1 + erf((x - mu) / (sigma * Math.SQRT2)));
  }

  // Calculate y values for both distributions
  return x.map((xi) => ({
    x: xi,
    pdf_std: dnorm(xi),
    pdf_param: dnorm(xi, mean, sd),
    cdf_std: pnorm(xi),
    cdf_param: pnorm(xi, mean, sd)
  }));
}

(() => {
  const sigma = [1, 2, 3];
  const sigmaColors = { 1: "#0ea5e9", 2: "#f59e0b", 3: "#8b5cf6" };
  const sigmaProb = { 1: "68.3%", 2: "95.5%", 3: "99.7%" };
  const verticalMarkers = [
    { x: mean, label: "Média (μ)" },
    { x: mean - sd, label: "-1σ", k: 1 },
    { x: mean + sd, label: "+1σ", k: 1 },
    { x: mean - 2 * sd, label: "-2σ", k: 2 },
    { x: mean + 2 * sd, label: "+2σ", k: 2 },
    { x: mean - 3 * sd, label: "-3σ", k: 3 },
    { x: mean + 3 * sd, label: "+3σ", k: 3 },
  ];

  const sigmaLinesPdf = sigma.map((k) => ({
    k,
    xLeft: mean - k * sd,
    xRight: mean + k * sd,
    y: (1 / (sd * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * k * k),
  }));

  const sigmaLineSegments = sigmaLinesPdf.flatMap((d) => ([
    { k: d.k, x: d.xLeft, y: d.y },
    { k: d.k, x: d.xRight, y: d.y },
  ]));

  return Plot.plot({
    caption: "Função de Densidade Normal (PDF)",
    height: 320,
    x: { label: "" },
    y: { label: "Densidade" },
    marks: [
      Plot.ruleY([0]),
      Plot.ruleX(verticalMarkers, { x: "x", title: "label", stroke: (d) => d.k ? sigmaColors[d.k] : "#94a3b8", strokeOpacity: (d) => d.k ? 0.8 : 0.45, strokeDasharray: (d) => d.k ? "6,3" : "4,4", strokeWidth: (d) => d.k ? 1.5 : 1, tip: true }),
      Plot.line(sigmaLineSegments, { x: "x", y: "y", stroke: (d) => sigmaColors[d.k], strokeOpacity: 0.8, strokeDasharray: "5,4", sort: "x", strokeWidth: 1.4, z: "k" }),
      Plot.text(sigmaLinesPdf, { x: mean, y: "y", text: (d) => `±${d.k}σ (${sigmaProb[d.k]})`, dy: -6, textAnchor: "middle", fill: (d) => sigmaColors[d.k], fontSize: 11, fontWeight: 600 }),
      Plot.areaY(normalDensities, { x: "x", y: "pdf_std", fill: "steelblue", fillOpacity: 0.2 }),
      Plot.areaY(normalDensities, { x: "x", y: "pdf_param", fill: "crimson", fillOpacity: 0.2 })
    ],
  });
})()

(() => {
  const sigmaColors = { 1: "#0ea5e9", 2: "#f59e0b", 3: "#8b5cf6" };
  const verticalMarkers = [
    { x: mean, label: "Média (μ)" },
    { x: mean - sd, label: "-1σ", k: 1 },
    { x: mean + sd, label: "+1σ", k: 1 },
    { x: mean - 2 * sd, label: "-2σ", k: 2 },
    { x: mean + 2 * sd, label: "+2σ", k: 2 },
    { x: mean - 3 * sd, label: "-3σ", k: 3 },
    { x: mean + 3 * sd, label: "+3σ", k: 3 },
  ];

  return Plot.plot({
    caption: "Função de Distribuição Acumulada (CDF)",
    height: 320,
    x: { label: "" },
    y: { label: "Probabilidade", domain: [0, 1] },
    marks: [
      Plot.ruleY([0]),
      Plot.ruleY([1], { strokeOpacity: 0.1 }),
      Plot.ruleX(verticalMarkers, { x: "x", title: "label", stroke: (d) => d.k ? sigmaColors[d.k] : "#94a3b8", strokeOpacity: (d) => d.k ? 0.8 : 0.45, strokeDasharray: (d) => d.k ? "6,3" : "4,4", strokeWidth: (d) => d.k ? 1.5 : 1, tip: true }),
      Plot.areaY(normalDensities, { x: "x", y: "cdf_std", fill: "steelblue", fillOpacity: 0.16 }),
      Plot.areaY(normalDensities, { x: "x", y: "cdf_param", fill: "crimson", fillOpacity: 0.16 }),
      Plot.lineY(normalDensities, { x: "x", y: "cdf_std", stroke: "steelblue", strokeWidth: 2.4, strokeDasharray: "6,4", strokeOpacity: 0.9, title: "CDF Normal Padrão" }),
      Plot.lineY(normalDensities, { x: "x", y: "cdf_param", stroke: "crimson", strokeWidth: 2.4, strokeOpacity: 0.9, title: "CDF Parametrizada" })
    ],
  });
})()