Advanced

Tutor model

i62 💰:9.4

i52 💰:7.9

🏆 i67 💰:62.5

i70 💰:125.0

i68 💰:125.0

🏆 i66 💰:75.0

i65 💰:125.0

i63 💰:62.5

i61 💰:75.0

i60 💰:9.4

i60 💰:37.5

i58 💰:62.5

i57 💰:22.5

i57 💰:37.5

i56 💰:45.0

⚡ i55 💰:11.25

i55 💰:37.5

i54 💰:62.5

i52 💰:35.0

i51 💰:37.5

i49 💰:15.0

i49 💰:62.5

i48 💰:11.3

i47 💰:7.5

i44 💰:25.0

i43 💰:37.5

i42 💰:187.5

i40 💰:5.0

i39 💰:100.0

i38 💰:37.5

i37 💰:11.0

i36 💰:187.5

i34 💰:12.5

i33 💰:37.5

i30 💰:1.0

i29 💰:1.5

i28 💰:150.0

i23 💰:20.0

i20 💰:4.0

i18 💰:1.0

i16 💰:25.0

i13 💰:1.5

Keep session private

What would you like to learn?

Override for the tutor's lesson content generation calls. Auto uses the system default (Claude Sonnet 5 for lesson text, Opus 5 for diagrams).

Lesson generation model

System default

i58 💰:18.8

i31 💰:11.0

i25 💰:31.3

Tutoring abilities

If someone opens a bottle of perfume in the corner of a quiet room with no draft, you can smell it across the room within seconds. How can the scent travel across still air without any wind pushing it?

The answer lies in the invisible, ceaseless chaos happening at the atomic scale.

Gas particles are in constant, **random motion**, traveling at high speeds in straight lines until they collide with each other or the walls of their container. Each collision changes the direction and speed of the particles unpredictably.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="aspect-ratio" content="4:3">
<style>
  * { box-sizing: border-box; margin: 0; padding: 0; }
  body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
    background: #f8f9fa;
    color: #1e2945;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: space-between;
    min-height: 100%;
    padding: 12px;
    user-select: none;
    -webkit-user-select: none;
  }
  .sim-container {
    width: 100%;
    max-width: 540px;
    display: flex;
    flex-direction: column;
    gap: 10px;
  }
  .canvas-wrapper {
    position: relative;
    width: 100%;
    height: 280px;
    background: #ffffff;
    border-radius: 12px;
    overflow: hidden;
    box-shadow: 0 2px 8px rgba(0,0,0,0.06);
    border: 1px solid #e6e6e6;
  }
  canvas {
    width: 100%;
    height: 100%;
    display: block;
  }
  .controls {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
    align-items: center;
    gap: 8px;
  }
  .btn-group {
    display: flex;
    gap: 6px;
  }
  .btn {
    background: #ffffff;
    border: 1px solid #d1d5db;
    color: #1e2945;
    padding: 8px 14px;
    border-radius: 8px;
    font-size: 14px;
    font-weight: 600;
    cursor: pointer;
    display: inline-flex;
    align-items: center;
    gap: 4px;
    transition: background 0.2s, box-shadow 0.2s;
  }
  .btn:active {
    background: #f3f4f6;
  }
  .btn.active {
    background: #22b7ff;
    color: #ffffff;
    border-color: #22b7ff;
    box-shadow: 0 0 0 2px rgba(34, 183, 255, 0.25);
  }
  .btn.active-orange {
    background: #ff8a00;
    color: #ffffff;
    border-color: #ff8a00;
    box-shadow: 0 0 0 2px rgba(255, 138, 0, 0.25);
  }
  .meter-box {
    display: flex;
    align-items: center;
    gap: 8px;
    background: #ffffff;
    padding: 6px 12px;
    border-radius: 8px;
    border: 1px solid #e6e6e6;
    font-size: 14px;
    font-weight: 600;
  }
  .meter-bar {
    width: 70px;
    height: 10px;
    background: #e5e7eb;
    border-radius: 5px;
    overflow: hidden;
  }
  .meter-fill {
    height: 100%;
    width: 30%;
    background: linear-gradient(90deg, #22b7ff, #ff8a00);
    border-radius: 5px;
    transition: width 0.4s ease;
  }
</style>
</head>
<body>

<div class="sim-container">
  <div class="canvas-wrapper">
    <canvas id="gasCanvas"></canvas>
  </div>

  <div class="controls">
    <div class="btn-group">
      <button class="btn active" id="coolBtn">❄️ Low</button>
      <button class="btn" id="hotBtn">🔥 High</button>
    </div>

    <button class="btn active-orange" id="traceBtn">📍 Trace Path</button>

    <div class="meter-box">
      <span>Kinetic Energy</span>
      <div class="meter-bar">
        <div class="meter-fill" id="meterFill"></div>
      </div>
    </div>
  </div>
</div>

<script>
  const canvas = document.getElementById('gasCanvas');
  const ctx = canvas.getContext('2d');
  const coolBtn = document.getElementById('coolBtn');
  const hotBtn = document.getElementById('hotBtn');
  const traceBtn = document.getElementById('traceBtn');
  const meterFill = document.getElementById('meterFill');

  let width, height;
  let targetSpeed = 1.6;
  let currentSpeedMult = 1.6;
  let showTrace = true;

  const NUM_PARTICLES = 26;
  const RADIUS = 6;
  const particles = [];
  const traceHistory = [];
  const MAX_TRAIL = 18;

  function resize() {
    const rect = canvas.getBoundingClientRect();
    const dpr = window.devicePixelRatio || 1;
    width = rect.width;
    height = rect.height;
    canvas.width = width * dpr;
    canvas.height = height * dpr;
    ctx.scale(dpr, dpr);
  }

  function initParticles() {
    particles.length = 0;
    traceHistory.length = 0;

    for (let i = 0; i < NUM_PARTICLES; i++) {
      let x, y, overlap;
      let attempts = 0;
      do {
        overlap = false;
        x = RADIUS + 10 + Math.random() * (width - 2 * RADIUS - 20);
        y = RADIUS + 10 + Math.random() * (height - 2 * RADIUS - 20);
        for (let j = 0; j < particles.length; j++) {
          const dx = x - particles[j].x;
          const dy = y - particles[j].y;
          if (Math.hypot(dx, dy) < RADIUS * 2.5) {
            overlap = true;
            break;
          }
        }
        attempts++;
      } while (overlap && attempts < 100);

      const angle = Math.random() * Math.PI * 2;
      particles.push({
        x,
        y,
        vx: Math.cos(angle),
        vy: Math.sin(angle),
        radius: i === 0 ? RADIUS + 1.5 : RADIUS,
        tracked: i === 0
      });
    }
  }

  function setTemp(isHot) {
    if (isHot) {
      targetSpeed = 4.2;
      hotBtn.classList.add('active');
      coolBtn.classList.remove('active');
      meterFill.style.width = '95%';
    } else {
      targetSpeed = 1.6;
      coolBtn.classList.add('active');
      hotBtn.classList.remove('active');
      meterFill.style.width = '30%';
    }
  }

  coolBtn.addEventListener('click', () => setTemp(false));
  hotBtn.addEventListener('click', () => setTemp(true));

  traceBtn.addEventListener('click', () => {
    showTrace = !showTrace;
    if (showTrace) {
      traceBtn.classList.add('active-orange');
    } else {
      traceBtn.classList.remove('active-orange');
      traceHistory.length = 0;
    }
  });

  function updatePhysics() {
    currentSpeedMult += (targetSpeed - currentSpeedMult) * 0.05;

    for (let i = 0; i < particles.length; i++) {
      const p = particles[i];
      p.x += p.vx * currentSpeedMult;
      p.y += p.vy * currentSpeedMult;

      let collidedWall = false;
      if (p.x - p.radius < 0) {
        p.x = p.radius;
        p.vx *= -1;
        collidedWall = true;
      } else if (p.x + p.radius > width) {
        p.x = width - p.radius;
        p.vx *= -1;
        collidedWall = true;
      }

      if (p.y - p.radius < 0) {
        p.y = p.radius;
        p.vy *= -1;
        collidedWall = true;
      } else if (p.y + p.radius > height) {
        p.y = height - p.radius;
        p.vy *= -1;
        collidedWall = true;
      }

      if (p.tracked && collidedWall && showTrace) {
        traceHistory.push({ x: p.x, y: p.y });
        if (traceHistory.length > MAX_TRAIL) traceHistory.shift();
      }
    }

    for (let i = 0; i < particles.length; i++) {
      for (let j = i + 1; j < particles.length; j++) {
        const p1 = particles[i];
        const p2 = particles[j];
        const dx = p2.x - p1.x;
        const dy = p2.y - p1.y;
        const dist = Math.hypot(dx, dy);
        const minDist = p1.radius + p2.radius;

        if (dist < minDist && dist > 0.001) {
          const nx = dx / dist;
          const ny = dy / dist;

          const kx = p1.vx - p2.vx;
          const ky = p1.vy - p2.vy;
          const p = 2 * (nx * kx + ny * ky) / 2;

          if (nx * kx + ny * ky > 0) {
            p1.vx -= p * nx;
            p1.vy -= p * ny;
            p2.vx += p * nx;
            p2.vy += p * ny;

            const overlap = (minDist - dist) / 2;
            p1.x -= nx * overlap;
            p1.y -= ny * overlap;
            p2.x += nx * overlap;
            p2.y += ny * overlap;

            if ((p1.tracked || p2.tracked) && showTrace) {
              const tracked = p1.tracked ? p1 : p2;
              traceHistory.push({ x: tracked.x, y: tracked.y });
              if (traceHistory.length > MAX_TRAIL) traceHistory.shift();
            }
          }
        }
      }
    }
  }

  function draw() {
    ctx.clearRect(0, 0, width, height);

    if (showTrace && traceHistory.length > 0) {
      const pTrack = particles[0];
      ctx.beginPath();
      ctx.moveTo(traceHistory[0].x, traceHistory[0].y);
      for (let i = 1; i < traceHistory.length; i++) {
        ctx.lineTo(traceHistory[i].x, traceHistory[i].y);
      }
      ctx.lineTo(pTrack.x, pTrack.y);
      ctx.strokeStyle = 'rgba(255, 138, 0, 0.4)';
      ctx.lineWidth = 2.5;
      ctx.setLineDash([4, 4]);
      ctx.stroke();
      ctx.setLineDash([]);

      for (let i = 0; i < traceHistory.length; i++) {
        ctx.beginPath();
        ctx.arc(traceHistory[i].x, traceHistory[i].y, 3, 0, Math.PI * 2);
        ctx.fillStyle = 'rgba(255, 138, 0, 0.5)';
        ctx.fill();
      }
    }

    for (let i = 0; i < particles.length; i++) {
      const p = particles[i];
      ctx.beginPath();
      ctx.arc(p.x, p.y, p.radius, 0, Math.PI * 2);

      if (p.tracked) {
        ctx.fillStyle = '#ff8a00';
        ctx.fill();
        ctx.lineWidth = 2;
        ctx.strokeStyle = '#ffffff';
        ctx.stroke();

        ctx.beginPath();
        ctx.arc(p.x, p.y, p.radius + 3, 0, Math.PI * 2);
        ctx.strokeStyle = 'rgba(255, 138, 0, 0.5)';
        ctx.lineWidth = 1.5;
        ctx.stroke();
      } else {
        ctx.fillStyle = '#22b7ff';
        ctx.fill();
        ctx.lineWidth = 1.5;
        ctx.strokeStyle = '#ffffff';
        ctx.stroke();
      }
    }
  }

  function loop() {
    updatePhysics();
    draw();
    requestAnimationFrame(loop);
  }

  window.addEventListener('resize', () => {
    resize();
  });

  resize();
  initParticles();
  requestAnimationFrame(loop);
</script>

</body>
</html>

In 1827, botanist Robert Brown observed pollen grains jiggling erratically in water, a phenomenon now called **Brownian motion**. In 1905, Albert Einstein published a mathematical proof showing that this jittery motion is direct evidence of unseen molecules colliding with the pollen from all sides.

So gas particles are constantly in motion — but what determines how fast they move?

**Kinetic energy** is the energy an object possesses due to its motion, calculated as $E_k = \frac{1}{2}mv^2$, where $m$ is mass and $v$ is velocity. The **temperature** of a gas is directly proportional to the **average kinetic energy** of its particles.

Not every particle moves at the exact same speed; instead, particles have a range of speeds. Heating a gas increases the average speed of the particles, shifting the entire speed distribution toward higher energies.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Molecular Motion & Kinetic Energy</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 10px;
      user-select: none;
    }

    .controls {
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 12px;
      width: 100%;
      max-width: 540px;
    }

    .btn-temp {
      flex: 1;
      padding: 8px 12px;
      font-size: 14px;
      font-weight: 600;
      border: 2px solid #e2e8f0;
      border-radius: 8px;
      background: #ffffff;
      color: #6b7280;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 6px;
      box-shadow: 0 1px 2px rgba(0,0,0,0.05);
    }
    .btn-temp.active {
      border-color: #22b7ff;
      color: #0284c7;
      background: #f0f9ff;
      box-shadow: 0 0 0 1px #22b7ff;
    }
    .btn-temp.hot.active {
      border-color: #ff4d4d;
      color: #dc2626;
      background: #fef2f2;
      box-shadow: 0 0 0 1px #ff4d4d;
    }

    .main-grid {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 10px;
      width: 100%;
      max-width: 540px;
    }
    @media (max-width: 440px) {
      .main-grid {
        grid-template-columns: 1fr;
      }
    }

    .panel {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 12px;
      padding: 8px;
      display: flex;
      flex-direction: column;
      align-items: center;
      position: relative;
      box-shadow: 0 2px 4px rgba(0,0,0,0.03);
    }

    .canvas-container {
      width: 100%;
      aspect-ratio: 1;
      position: relative;
    }

    canvas {
      width: 100%;
      height: 100%;
      display: block;
      border-radius: 8px;
    }

    .legend {
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 16px;
      font-size: 13px;
      font-weight: 500;
      color: #6b7280;
      margin-top: 4px;
    }
    .dot-label {
      display: inline-flex;
      align-items: center;
      gap: 5px;
    }
    .color-dot {
      width: 10px;
      height: 10px;
      border-radius: 50%;
    }
  </style>
</head>
<body>

  <div class="controls">
    <button class="btn-temp active" id="btnLow">
      <span>❄️ Low Temp (200 K)</span>
    </button>
    <button class="btn-temp hot" id="btnHigh">
      <span>🔥 High Temp (600 K)</span>
    </button>
  </div>

  <div class="main-grid">
    <div class="panel">
      <div class="canvas-container">
        <canvas id="simCanvas"></canvas>
      </div>
    </div>
    <div class="panel">
      <div class="canvas-container">
        <canvas id="graphCanvas"></canvas>
      </div>
    </div>
  </div>

  <div class="legend">
    <div class="dot-label"><span class="color-dot" style="background:#22b7ff;"></span>Slow</div>
    <div class="dot-label"><span class="color-dot" style="background:#a855f7;"></span>Medium</div>
    <div class="dot-label"><span class="color-dot" style="background:#ff4d4d;"></span>Fast</div>
  </div>

  <script>
    const simCanvas = document.getElementById('simCanvas');
    const graphCanvas = document.getElementById('graphCanvas');
    const ctxSim = simCanvas.getContext('2d');
    const ctxGraph = graphCanvas.getContext('2d');
    const btnLow = document.getElementById('btnLow');
    const btnHigh = document.getElementById('btnHigh');

    let currentT = 200;
    let targetT = 200;
    const NUM_PARTICLES = 36;
    const particles = [];

    function resize() {
      const dpr = window.devicePixelRatio || 1;
      const rect1 = simCanvas.parentElement.getBoundingClientRect();
      const rect2 = graphCanvas.parentElement.getBoundingClientRect();

      simCanvas.width = rect1.width * dpr;
      simCanvas.height = rect1.height * dpr;
      graphCanvas.width = rect2.width * dpr;
      graphCanvas.height = rect2.height * dpr;

      ctxSim.scale(dpr, dpr);
      ctxGraph.scale(dpr, dpr);
    }
    window.addEventListener('resize', resize);

    function sampleSpeed(T) {
      // 2D Maxwell-Boltzmann / Rayleigh distribution
      const u1 = Math.max(1e-6, Math.random());
      const u2 = Math.random();
      const z = Math.sqrt(-2.0 * Math.log(u1));
      const speed = z * Math.sqrt(T * 0.045);
      return Math.max(0.4, speed);
    }

    function initParticles() {
      for (let i = 0; i < NUM_PARTICLES; i++) {
        const speed = sampleSpeed(currentT);
        const angle = Math.random() * Math.PI * 2;
        particles.push({
          x: 20 + Math.random() * 200,
          y: 20 + Math.random() * 200,
          vx: Math.cos(angle) * speed,
          vy: Math.sin(angle) * speed,
          radius: 5
        });
      }
    }

    function getColor(speed) {
      // Color scale based on speed: < 2.0 (blue), 2.0-4.0 (purple), > 4.0 (red)
      if (speed < 2.2) return '#22b7ff';
      if (speed < 4.2) return '#a855f7';
      return '#ff4d4d';
    }

    function setTemperature(T) {
      targetT = T;
      if (T === 200) {
        btnLow.classList.add('active');
        btnHigh.classList.remove('active');
      } else {
        btnHigh.classList.add('active');
        btnLow.classList.remove('active');
      }
    }

    btnLow.addEventListener('click', () => setTemperature(200));
    btnHigh.addEventListener('click', () => setTemperature(600));

    function updateParticles(w, h) {
      // Smoothly adjust temperature
      currentT += (targetT - currentT) * 0.05;

      for (let i = 0; i < particles.length; i++) {
        const p = particles[i];
        p.x += p.vx;
        p.y += p.vy;

        // Wall collisions
        if (p.x - p.radius < 0) { p.x = p.radius; p.vx *= -1; }
        if (p.x + p.radius > w) { p.x = w - p.radius; p.vx *= -1; }
        if (p.y - p.radius < 0) { p.y = p.radius; p.vy *= -1; }
        if (p.y + p.radius > h) { p.y = h - p.radius; p.vy *= -1; }

        // Thermal relaxation towards target distribution
        const currentSpeed = Math.hypot(p.vx, p.vy);
        const desiredSpeed = sampleSpeed(currentT);
        const blendedSpeed = currentSpeed + (desiredSpeed - currentSpeed) * 0.02;
        if (currentSpeed > 0) {
          p.vx = (p.vx / currentSpeed) * blendedSpeed;
          p.vy = (p.vy / currentSpeed) * blendedSpeed;
        }
      }
    }

    function drawSim() {
      const w = simCanvas.width / (window.devicePixelRatio || 1);
      const h = simCanvas.height / (window.devicePixelRatio || 1);
      ctxSim.clearRect(0, 0, w, h);

      // Chamber background
      ctxSim.fillStyle = '#f1f5f9';
      ctxSim.fillRect(0, 0, w, h);

      // Draw particles
      for (const p of particles) {
        const speed = Math.hypot(p.vx, p.vy);
        ctxSim.beginPath();
        ctxSim.arc(p.x, p.y, p.radius, 0, Math.PI * 2);
        ctxSim.fillStyle = getColor(speed);
        ctxSim.fill();
        ctxSim.lineWidth = 1.5;
        ctxSim.strokeStyle = '#ffffff';
        ctxSim.stroke();
      }
    }

    function drawGraph() {
      const w = graphCanvas.width / (window.devicePixelRatio || 1);
      const h = graphCanvas.height / (window.devicePixelRatio || 1);
      ctxGraph.clearRect(0, 0, w, h);

      const padL = 34;
      const padB = 30;
      const padT = 16;
      const padR = 16;
      const graphW = w - padL - padR;
      const graphH = h - padB - padT;

      // Axes
      ctxGraph.strokeStyle = '#cbd5e1';
      ctxGraph.lineWidth = 1.5;
      ctxGraph.beginPath();
      ctxGraph.moveTo(padL, padT);
      ctxGraph.lineTo(padL, h - padB);
      ctxGraph.lineTo(w - padR, h - padB);
      ctxGraph.stroke();

      // Axis labels
      ctxGraph.fillStyle = '#64748b';
      ctxGraph.font = '11px system-ui, sans-serif';
      ctxGraph.textAlign = 'center';
      ctxGraph.fillText('Speed →', padL + graphW / 2, h - 8);

      ctxGraph.save();
      ctxGraph.translate(12, padT + graphH / 2);
      ctxGraph.rotate(-Math.PI / 2);
      ctxGraph.fillText('Particles', 0, 0);
      ctxGraph.restore();

      // Rayleigh distribution curve: f(v) = (v / sigma^2) * exp(-v^2 / (2*sigma^2))
      const sigma = Math.sqrt(currentT * 0.045);
      const maxV = 8.5;

      ctxGraph.beginPath();
      let peakX = 0;
      let peakY = 0;
      let maxVal = 0;

      for (let px = 0; px <= graphW; px += 2) {
        const v = (px / graphW) * maxV;
        const f = (v / (sigma * sigma)) * Math.exp(-(v * v) / (2 * sigma * sigma));
        const py = (h - padB) - (f * 180);
        if (px === 0) ctxGraph.moveTo(padL + px, py);
        else ctxGraph.lineTo(padL + px, py);

        if (f > maxVal) {
          maxVal = f;
          peakX = padL + px;
          peakY = py;
        }
      }

      ctxGraph.strokeStyle = currentT > 350 ? '#ff4d4d' : '#22b7ff';
      ctxGraph.lineWidth = 2.5;
      ctxGraph.stroke();

      // Peak / Average marker
      ctxGraph.setLineDash([3, 3]);
      ctxGraph.strokeStyle = '#94a3b8';
      ctxGraph.beginPath();
      ctxGraph.moveTo(peakX, peakY);
      ctxGraph.lineTo(peakX, h - padB);
      ctxGraph.stroke();
      ctxGraph.setLineDash([]);

      ctxGraph.beginPath();
      ctxGraph.arc(peakX, peakY, 4, 0, Math.PI * 2);
      ctxGraph.fillStyle = currentT > 350 ? '#ff4d4d' : '#22b7ff';
      ctxGraph.fill();
    }

    function loop() {
      const w = simCanvas.width / (window.devicePixelRatio || 1);
      const h = simCanvas.height / (window.devicePixelRatio || 1);
      updateParticles(w, h);
      drawSim();
      drawGraph();
      requestAnimationFrame(loop);
    }

    resize();
    initParticles();
    requestAnimationFrame(loop);
  </script>
</body>
</html>

What happens mathematically to particle speed when we double the absolute temperature?

Suppose a sample of neon gas at an absolute temperature of $T_1 = 300\text{ K}$ is heated to $T_2 = 600\text{ K}$ at constant volume. Let's calculate the factor by which the average kinetic energy and average particle speed change.

Because average kinetic energy is directly proportional to absolute temperature ($\text{Average } E_k \propto T$), doubling the temperature from $300\text{ K}$ to $600\text{ K}$ doubles the average kinetic energy: $$\frac{E_{k,2}}{E_{k,1}} = \frac{600}{300} = 2$$

Since $E_k = \frac{1}{2}mv^2$, the speed $v$ is proportional to $\sqrt{E_k}$. Doubling the kinetic energy increases the average speed not by $2$, but by $\sqrt{2} \approx 1.41$ times (a $41\%$ increase).

A common mistake is thinking that heating a gas makes the individual particles expand in size. Gas particles themselves remain the exact same size — they simply move faster, collide harder, and possess greater kinetic energy.

Gas **pressure** is the net force exerted by gas particles colliding with the walls of their container per unit area ($P = \frac{F}{A}$).

When temperature rises at constant volume, faster-moving molecules collide with the walls more frequently and with a greater **momentum change** per collision.

This produces a greater total force per unit area, raising the gas pressure. This principle is known as **Gay-Lussac's law** or the **Pressure Law**, stating that $P \propto T$ at constant volume.

When gas molecules strike the walls of a container, each collision exerts a tiny push. **Gas pressure** is the total force exerted per unit area by these continuous impacts.

As temperature rises at constant volume, faster-moving molecules collide with the walls more frequently and with greater momentum change per collision.

This generates a larger net force per unit area, increasing the pressure. This relationship is known as the **Pressure Law** (or **Gay-Lussac's law**): for a fixed mass of gas at constant volume, pressure is directly proportional to absolute temperature ($P \propto T$).

science

Molecular Motion and Kinetic Energy in Gases. Describe the random motion of gas molecules and explain that the temperature of a gas is directly related to the average kinetic energy of its particles.

GCSE Physics: Particle Model of Matter and Gas Pressure

Gas Properties (HTML5 Interactive Simulation)

Isaac Physics: Gas Behaviour and Temperature-Pressure Relationships

To ensure student mastery of GCSE qualitative gas pressure questions, use a 4-link causal chain framework: (1) Temperature $\uparrow$ $\rightarrow$ (2) Average Kinetic Energy & Speed $\uparrow$ $\rightarrow$ (3) Collision Frequency $\uparrow$ $\rightarrow$ (4) Force / Momentum Change per Impact $\uparrow$ $\rightarrow$ Pressure $\uparrow$. Emphasise that in GCSE mark schemes, students must mention both 'more frequent collisions' and 'harder/greater force collisions' to attain full marks.

Molecular Motion and Kinetic Energy in Gases

Random Motion in Gases

Temperature and Kinetic Energy

Worked Example: Temperature Scaling