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

Have you ever noticed car wheels in a video looking like they are spinning backward or standing completely still? That illusion happens because the camera's shutter takes snapshots too slowly to track the wheel's true rotational speed.

In electronics, **sampling** means measuring a continuous **analog signal** (a smooth, unbroken waveform of voltage or current) at regular intervals of time ($T_s$) to turn it into digital numbers.

<!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: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
    }

    .btn-group {
      display: flex;
      gap: 6px;
      width: 100%;
      max-width: 540px;
      justify-content: center;
    }

    .mode-btn {
      flex: 1;
      padding: 8px 6px;
      font-size: 13px;
      font-weight: 600;
      border: 1px solid #d1d5db;
      border-radius: 8px;
      background: #ffffff;
      color: #4b5563;
      cursor: pointer;
      text-align: center;
      transition: background 0.2s, color 0.2s, box-shadow 0.2s;
    }

    .mode-btn.active {
      background: #2563eb;
      color: #ffffff;
      border-color: #2563eb;
      box-shadow: 0 2px 6px rgba(37, 99, 235, 0.25);
    }

    .canvas-container {
      position: relative;
      width: 100%;
      max-width: 540px;
      background: #ffffff;
      border: 1px solid #e5e7eb;
      border-radius: 10px;
      margin: 10px 0;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
      display: flex;
      flex-direction: column;
    }

    canvas {
      width: 100%;
      height: 220px;
      display: block;
    }

    .legend {
      display: flex;
      flex-wrap: wrap;
      justify-content: center;
      gap: 12px;
      padding: 8px 12px;
      border-top: 1px solid #f3f4f6;
      font-size: 12px;
      font-weight: 600;
    }

    .legend-item {
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .line-sample {
      width: 16px;
      height: 3px;
      border-radius: 2px;
    }

    .dot-sample {
      width: 8px;
      height: 8px;
      border-radius: 50%;
      background: #d97706;
    }

    .status-badge {
      display: inline-flex;
      align-items: center;
      gap: 4px;
      font-size: 13px;
      font-weight: 700;
      padding: 4px 12px;
      border-radius: 20px;
      margin-bottom: 2px;
    }

    .badge-danger {
      background: #fee2e2;
      color: #b91c1c;
    }

    .badge-success {
      background: #dcfce7;
      color: #15803d;
    }
  </style>
</head>
<body>

  
  <div class="btn-group">
    <button class="mode-btn active" onclick="setMode(0)">f<sub>s</sub> &lt; 2f<br><span style="font-weight:400;font-size:11px">Under</span></button>
    <button class="mode-btn" onclick="setMode(1)">f<sub>s</sub> = 2f<br><span style="font-weight:400;font-size:11px">Nyquist</span></button>
    <button class="mode-btn" onclick="setMode(2)">f<sub>s</sub> &gt; 2f<br><span style="font-weight:400;font-size:11px">Over</span></button>
  </div>

  
  <div class="canvas-container">
    <canvas id="plotCanvas"></canvas>
    <div class="legend">
      <div class="legend-item">
        <div class="line-sample" style="background: #94a3b8; border-top: 1px dashed #64748b;"></div>
        <span>Original Signal (f)</span>
      </div>
      <div class="legend-item">
        <div class="dot-sample"></div>
        <span>Samples (T<sub>s</sub>)</span>
      </div>
      <div class="legend-item">
        <div class="line-sample" id="reconLineSample" style="background: #ef4444;"></div>
        <span id="reconLabel">Reconstructed</span>
      </div>
    </div>
  </div>

  
  <div id="statusBadge" class="status-badge badge-danger">
    ⚠️ Aliasing Distortion (False Frequency)
  </div>

  <script>
    const canvas = document.getElementById('plotCanvas');
    const ctx = canvas.getContext('2d');
    const buttons = document.querySelectorAll('.mode-btn');
    const statusBadge = document.getElementById('statusBadge');
    const reconLineSample = document.getElementById('reconLineSample');

    let currentMode = 0; // 0: Undersampled, 1: Nyquist, 2: Oversampled
    const signalFreq = 3; // 3 cycles across plot

    const configs = [
      {
        sampleRate: 4, // fs = 1.33f (< 2f) -> creates aliased wave of freq = |4-3| = 1 cycle
        badgeText: '⚠️ Aliasing (Lost Detail & False Wave)',
        badgeClass: 'status-badge badge-danger',
        reconColor: '#ef4444',
        aliasFreq: 1
      },
      {
        sampleRate: 6, // fs = 2f (Nyquist rate)
        badgeText: '✓ Exact Nyquist Minimum (2 samples/cycle)',
        badgeClass: 'status-badge badge-success',
        reconColor: '#10b981',
        aliasFreq: 3
      },
      {
        sampleRate: 18, // fs = 6f (> 2f oversampled)
        badgeText: '✓ Clean Accurate Reconstruction',
        badgeClass: 'status-badge badge-success',
        reconColor: '#2563eb',
        aliasFreq: 3
      }
    ];

    function setMode(index) {
      currentMode = index;
      buttons.forEach((btn, idx) => {
        btn.classList.toggle('active', idx === index);
      });
      
      const config = configs[index];
      statusBadge.className = config.badgeClass;
      statusBadge.textContent = config.badgeText;
      reconLineSample.style.background = config.reconColor;

      draw();
    }

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

    window.addEventListener('resize', resize);

    function draw() {
      const w = canvas.getBoundingClientRect().width;
      const h = canvas.getBoundingClientRect().height;
      if (!w || !h) return;

      ctx.clearRect(0, 0, w, h);

      const midY = h / 2;
      const amp = h * 0.36;
      const padX = 24;
      const plotW = w - (padX * 2);

      // Draw Center Baseline
      ctx.strokeStyle = '#e2e8f0';
      ctx.lineWidth = 1;
      ctx.beginPath();
      ctx.moveTo(padX, midY);
      ctx.lineTo(w - padX, midY);
      ctx.stroke();

      // 1. Draw Original Wave (Dashed Gray)
      ctx.strokeStyle = '#94a3b8';
      ctx.lineWidth = 2;
      ctx.setLineDash([4, 4]);
      ctx.beginPath();
      for (let px = 0; px <= plotW; px++) {
        const t = px / plotW;
        const y = midY - Math.sin(t * Math.PI * 2 * signalFreq) * amp;
        if (px === 0) ctx.moveTo(padX + px, y);
        else ctx.lineTo(padX + px, y);
      }
      ctx.stroke();
      ctx.setLineDash([]);

      const config = configs[currentMode];
      const samplesCount = config.sampleRate;
      const samplePoints = [];

      // Calculate Samples
      const phaseShift = currentMode === 1 ? Math.PI / 4 : 0; // offset Nyquist slightly to avoid all zeros
      for (let i = 0; i <= samplesCount; i++) {
        const t = i / samplesCount;
        const x = padX + t * plotW;
        const y = midY - Math.sin(t * Math.PI * 2 * signalFreq + phaseShift) * amp;
        samplePoints.push({ x, y, t });
      }

      // 2. Draw Reconstructed Wave
      ctx.strokeStyle = config.reconColor;
      ctx.lineWidth = 2.5;
      ctx.beginPath();
      for (let px = 0; px <= plotW; px++) {
        const t = px / plotW;
        let y;
        if (currentMode === 0) {
          // Aliased apparent slow sine wave connecting the sample dots
          y = midY - Math.sin(t * Math.PI * 2 * config.aliasFreq) * amp;
        } else {
          // Reconstructed true sine wave
          y = midY - Math.sin(t * Math.PI * 2 * signalFreq + phaseShift) * amp;
        }
        if (px === 0) ctx.moveTo(padX + px, y);
        else ctx.lineTo(padX + px, y);
      }
      ctx.stroke();

      // 3. Draw Sampling Stems & Points
      samplePoints.forEach(pt => {
        // Vertical Stem
        ctx.strokeStyle = 'rgba(217, 119, 6, 0.4)';
        ctx.lineWidth = 1.5;
        ctx.beginPath();
        ctx.moveTo(pt.x, midY);
        ctx.lineTo(pt.x, pt.y);
        ctx.stroke();

        // Sample Dot
        ctx.fillStyle = '#d97706';
        ctx.beginPath();
        ctx.arc(pt.x, pt.y, 4.5, 0, Math.PI * 2);
        ctx.fill();

        ctx.fillStyle = '#ffffff';
        ctx.beginPath();
        ctx.arc(pt.x, pt.y, 1.5, 0, Math.PI * 2);
        ctx.fill();
      });
    }

    // Initial setup
    resize();
  </script>
</body>
</html>

How fast must you take these digital snapshots to guarantee you can reconstruct the original analog signal without losing any detail?

In 1928, AT&T engineer Harry Nyquist investigated telegraph transmission speeds, and Claude Shannon mathematically proved the result for all digital communication in 1949.

The **Nyquist-Shannon sampling theorem** states that to perfectly reconstruct an analog signal, the **sampling frequency** ($f_s$) must be at least twice the highest frequency component ($f_{\text{max}}$) present in that signal.

<!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: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
    }

    .controls {
      display: flex;
      flex-wrap: wrap;
      gap: 8px;
      justify-content: center;
      width: 100%;
      max-width: 540px;
      margin-bottom: 8px;
    }

    .btn {
      flex: 1 1 140px;
      padding: 8px 12px;
      border-radius: 8px;
      border: 1px solid #e2e8f0;
      background: #ffffff;
      color: #1e2945;
      font-size: 13px;
      font-weight: 600;
      cursor: pointer;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 2px;
      transition: background 0.2s, border-color 0.2s, box-shadow 0.2s;
    }

    .btn .sub {
      font-size: 11px;
      font-weight: 500;
      color: #64748b;
    }

    .btn.active {
      background: #eff6ff;
      border-color: #2563eb;
      color: #2563eb;
      box-shadow: 0 0 0 2px rgba(37, 99, 235, 0.15);
    }

    .btn.active .sub {
      color: #2563eb;
    }

    .graph-card {
      position: relative;
      width: 100%;
      max-width: 540px;
      background: #ffffff;
      border: 1px solid #e6e6e6;
      border-radius: 12px;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 8px;
    }

    .status-badge {
      display: inline-flex;
      align-items: center;
      gap: 6px;
      padding: 4px 10px;
      border-radius: 20px;
      font-size: 13px;
      font-weight: 600;
    }

    .status-und {
      background: #fef2f2;
      color: #dc2626;
      border: 1px solid #fecaca;
    }

    .status-nyq {
      background: #f0fdf4;
      color: #16a34a;
      border: 1px solid #bbf7d0;
    }

    .status-ovr {
      background: #eff6ff;
      color: #2563eb;
      border: 1px solid #bfdbfe;
    }

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

    .legend {
      display: flex;
      flex-wrap: wrap;
      justify-content: center;
      gap: 12px;
      width: 100%;
      font-size: 12px;
      color: #475569;
    }

    .legend-item {
      display: flex;
      align-items: center;
      gap: 5px;
    }

    .line-sample {
      width: 16px;
      height: 2px;
    }

    .dot-sample {
      width: 8px;
      height: 8px;
      border-radius: 50%;
      background: #dc2626;
    }
  </style>
</head>
<body>

  <div class="controls">
    <button class="btn active" id="btn-nyq" onclick="setMode('nyquist')">
      <span>f<sub>s</sub> = 2 f<sub>max</sub></span>
      <span class="sub">Nyquist Rate</span>
    </button>
    <button class="btn" id="btn-und" onclick="setMode('under')">
      <span>f<sub>s</sub> &lt; 2 f<sub>max</sub></span>
      <span class="sub">Undersampled</span>
    </button>
    <button class="btn" id="btn-ovr" onclick="setMode('over')">
      <span>f<sub>s</sub> = 4 f<sub>max</sub></span>
      <span class="sub">Oversampled</span>
    </button>
  </div>

  <div class="graph-card">
    <div id="statusBadge" class="status-badge status-nyq">
      <span>✓ 2 Samples/Cycle (Reconstructable)</span>
    </div>

    <canvas id="plot" width="540" height="190"></canvas>

    <div class="legend">
      <div class="legend-item">
        <span class="line-sample" style="background:#94a3b8; border-top: 2px dashed #94a3b8; height:0;"></span>
        <span>Original Signal</span>
      </div>
      <div class="legend-item">
        <span class="dot-sample" id="sampleDotIcon"></span>
        <span>Sample Points</span>
      </div>
      <div class="legend-item">
        <span class="line-sample" id="reconLineIcon" style="background:#16a34a; height:2px;"></span>
        <span id="reconLabel">Reconstruction</span>
      </div>
    </div>
  </div>

  <script>
    const canvas = document.getElementById('plot');
    const ctx = canvas.getContext('2d');

    let currentMode = 'nyquist';

    function setMode(mode) {
      currentMode = mode;
      document.getElementById('btn-und').classList.toggle('active', mode === 'under');
      document.getElementById('btn-nyq').classList.toggle('active', mode === 'nyquist');
      document.getElementById('btn-ovr').classList.toggle('active', mode === 'over');

      const badge = document.getElementById('statusBadge');
      const reconLine = document.getElementById('reconLineIcon');
      const reconLabel = document.getElementById('reconLabel');

      if (mode === 'under') {
        badge.className = 'status-badge status-und';
        badge.innerHTML = '⚠️ Aliasing: False Low Frequency';
        reconLine.style.background = '#dc2626';
        reconLabel.textContent = 'False Alias Wave';
      } else if (mode === 'nyquist') {
        badge.className = 'status-badge status-nyq';
        badge.innerHTML = '✓ Minimum Rate: Peak &amp; Trough Captured';
        reconLine.style.background = '#16a34a';
        reconLabel.textContent = 'Reconstruction';
      } else {
        badge.className = 'status-badge status-ovr';
        badge.innerHTML = '✦ High Fidelity: Accurate Waveform';
        reconLine.style.background = '#2563eb';
        reconLabel.textContent = 'Accurate Wave';
      }

      draw();
    }

    function draw() {
      const W = canvas.width;
      const H = canvas.height;
      ctx.clearRect(0, 0, W, H);

      const midY = H / 2;
      const amp = 60;
      const cycles = 3;
      const signalFreq = (cycles * 2 * Math.PI) / (W - 40);
      const padX = 20;

      // Draw horizontal axis
      ctx.strokeStyle = '#e2e8f0';
      ctx.lineWidth = 1.5;
      ctx.beginPath();
      ctx.moveTo(padX, midY);
      ctx.lineTo(W - padX, midY);
      ctx.stroke();

      // Original Continuous Signal (True Sine Wave)
      ctx.strokeStyle = '#94a3b8';
      ctx.lineWidth = 2;
      ctx.setLineDash([4, 4]);
      ctx.beginPath();
      for (let x = padX; x <= W - padX; x++) {
        const y = midY - amp * Math.sin((x - padX) * signalFreq);
        if (x === padX) ctx.moveTo(x, y);
        else ctx.lineTo(x, y);
      }
      ctx.stroke();
      ctx.setLineDash([]);

      // Compute sample positions
      let samplePoints = [];
      let sampleColor = '#16a34a';

      if (currentMode === 'under') {
        sampleColor = '#dc2626';
        // fs = 1.2 * fmax (less than 2 samples per cycle, creates apparent lower freq alias)
        const step = (2 * Math.PI / signalFreq) / 1.2;
        for (let x = padX; x <= W - padX; x += step) {
          const y = midY - amp * Math.sin((x - padX) * signalFreq);
          samplePoints.push({ x, y });
        }
      } else if (currentMode === 'nyquist') {
        sampleColor = '#16a34a';
        // fs = 2 * fmax (exactly 2 samples per cycle at peaks and troughs)
        const cycleWidth = (2 * Math.PI) / signalFreq;
        const step = cycleWidth / 2;
        const offset = step / 2; // sample at 90 deg (peaks) and 270 deg (troughs)
        for (let x = padX + offset; x <= W - padX; x += step) {
          const y = midY - amp * Math.sin((x - padX) * signalFreq);
          samplePoints.push({ x, y });
        }
      } else {
        sampleColor = '#2563eb';
        // fs = 4 * fmax
        const step = (2 * Math.PI / signalFreq) / 4;
        for (let x = padX; x <= W - padX; x += step) {
          const y = midY - amp * Math.sin((x - padX) * signalFreq);
          samplePoints.push({ x, y });
        }
      }

      // Draw Reconstructed / Apparent Wave
      ctx.lineWidth = 2.5;
      if (currentMode === 'under') {
        // Apparent Alias Wave: frequency = |f_s - f_in| = 0.2 f
        ctx.strokeStyle = '#dc2626';
        const aliasFreq = signalFreq * 0.2;
        ctx.beginPath();
        for (let x = padX; x <= W - padX; x++) {
          const y = midY - amp * Math.sin((x - padX) * aliasFreq);
          if (x === padX) ctx.moveTo(x, y);
          else ctx.lineTo(x, y);
        }
        ctx.stroke();
      } else if (currentMode === 'nyquist') {
        ctx.strokeStyle = '#16a34a';
        ctx.beginPath();
        for (let x = padX; x <= W - padX; x++) {
          const y = midY - amp * Math.sin((x - padX) * signalFreq);
          if (x === padX) ctx.moveTo(x, y);
          else ctx.lineTo(x, y);
        }
        ctx.stroke();
      } else {
        ctx.strokeStyle = '#2563eb';
        ctx.beginPath();
        for (let x = padX; x <= W - padX; x++) {
          const y = midY - amp * Math.sin((x - padX) * signalFreq);
          if (x === padX) ctx.moveTo(x, y);
          else ctx.lineTo(x, y);
        }
        ctx.stroke();
      }

      // Draw Sample Stems and Dots
      samplePoints.forEach(pt => {
        // Stem
        ctx.strokeStyle = 'rgba(100, 116, 139, 0.35)';
        ctx.lineWidth = 1;
        ctx.setLineDash([2, 2]);
        ctx.beginPath();
        ctx.moveTo(pt.x, midY);
        ctx.lineTo(pt.x, pt.y);
        ctx.stroke();
        ctx.setLineDash([]);

        // Dot
        ctx.fillStyle = sampleColor;
        ctx.beginPath();
        ctx.arc(pt.x, pt.y, 4.5, 0, 2 * Math.PI);
        ctx.fill();
        ctx.strokeStyle = '#ffffff';
        ctx.lineWidth = 1.5;
        ctx.stroke();
      });
    }

    draw();
  </script>
</body>
</html>

Why must it be at least double? Every periodic wave alternates between a positive half-cycle and a negative half-cycle, so you need at least two sample points per cycle to establish its peak, trough, and repetition rate.

The absolute minimum allowable sampling rate ($2 f_{\text{max}}$) is called the **Nyquist rate**, while the theoretical maximum frequency a given system can capture ($f_s / 2$) is called the **Nyquist frequency**.

How does this rule determine the hardware specifications for telephone lines and studio-quality audio?

Suppose a telephone system filters human speech so that the highest transmitted voice frequency is $f_{\text{max}} = 3.4\text{ kHz}$. To prevent distortion, what is the minimum sampling frequency required?

Using our formula: $$f_s \ge 2 \times f_{\text{max}} = 2 \times 3.4\text{ kHz} = 6.8\text{ kHz}$$ In commercial telecommunications, standard Pulse Code Modulation (PCM) systems round this up to **$8\text{ kHz}$** (8,000 samples per second) to give a comfortable safety margin.

<!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;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
    }
    body {
      background: #ffffff;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      gap: 10px;
      user-select: none;
    }
    .controls {
      display: flex;
      flex-wrap: wrap;
      gap: 8px;
      align-items: center;
      justify-content: space-between;
    }
    .btn-group {
      display: flex;
      gap: 6px;
      flex-wrap: wrap;
    }
    button {
      background: #f1f5f9;
      border: 1px solid #cbd5e1;
      border-radius: 8px;
      padding: 6px 10px;
      font-size: 13px;
      font-weight: 600;
      color: #334155;
      cursor: pointer;
      transition: background 0.2s, border-color 0.2s, color 0.2s;
    }
    button.active {
      background: #2563eb;
      border-color: #2563eb;
      color: #ffffff;
    }
    .slider-container {
      display: flex;
      align-items: center;
      gap: 8px;
      background: #f8fafc;
      padding: 4px 10px;
      border-radius: 8px;
      border: 1px solid #e2e8f0;
      font-size: 13px;
      font-weight: 600;
    }
    input[type="range"] {
      width: 110px;
      cursor: pointer;
      accent-color: #2563eb;
    }
    .status-bar {
      display: flex;
      align-items: center;
      justify-content: space-between;
      padding: 6px 12px;
      border-radius: 8px;
      font-size: 13px;
      font-weight: 600;
      transition: background 0.2s, color 0.2s;
    }
    .status-aliased {
      background: #fef2f2;
      border: 1px solid #fecaca;
      color: #dc2626;
    }
    .status-nyquist {
      background: #fefce8;
      border: 1px solid #fef08a;
      color: #b45309;
    }
    .status-good {
      background: #f0fdf4;
      border: 1px solid #bbf7d0;
      color: #16a34a;
    }
    .graph-wrapper {
      position: relative;
      width: 100%;
      height: 230px;
      background: #f8fafc;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      overflow: hidden;
    }
    svg {
      width: 100%;
      height: 100%;
      display: block;
    }
    .legend {
      display: flex;
      gap: 14px;
      justify-content: center;
      align-items: center;
      font-size: 12px;
      font-weight: 600;
      color: #475569;
    }
    .legend-item {
      display: flex;
      align-items: center;
      gap: 5px;
    }
    .legend-line {
      width: 16px;
      height: 3px;
      border-radius: 2px;
    }
    .legend-dot {
      width: 8px;
      height: 8px;
      border-radius: 50%;
      background: #0f172a;
    }
  </style>
</head>
<body>

  <div class="controls">
    <div class="btn-group">
      <button id="btnUnder" onclick="setRatio(1.25)">Under (1.25×</button>
      <button id="btnNyquist" onclick="setRatio(2.0)">Nyquist (2.0×)</button>
      <button id="btnOver" class="active" onclick="setRatio(4.0)">Over (4.0×)</button>
    </div>
    <div class="slider-container">
      <span>Rate:</span>
      <input type="range" id="rateSlider" min="0.8" max="5.0" step="0.05" value="4.0">
      <span id="rateLabel" style="min-width: 40px;">4.0×</span>
    </div>
  </div>

  <div id="statusBar" class="status-bar status-good">
    <span id="statusFormula">fₛ = 4.0 fₘₐₓ ≥ 2 fₘₐₓ</span>
    <span id="statusText">✓ Accurate Reconstruction</span>
  </div>

  <div class="graph-wrapper">
    <svg id="plotSvg" viewBox="0 0 600 230">
      
      <line x1="40" y1="35" x2="570" y2="35" stroke="#e2e8f0" stroke-width="1" stroke-dasharray="3 3"/>
      <line x1="40" y1="115" x2="570" y2="115" stroke="#cbd5e1" stroke-width="1.5"/>
      <line x1="40" y1="195" x2="570" y2="195" stroke="#e2e8f0" stroke-width="1" stroke-dasharray="3 3"/>

      
      <path id="aliasPath" fill="none" stroke="#ef4444" stroke-width="2.5" stroke-dasharray="5 4" opacity="0.9"/>
      <path id="originalPath" fill="none" stroke="#2563eb" stroke-width="2.5"/>
      <g id="samplesGroup"></g>

      
      <text x="575" y="119" font-size="11" fill="#94a3b8" font-weight="600">t</text>
      <text x="15" y="40" font-size="11" fill="#94a3b8" font-weight="600">+1</text>
      <text x="20" y="119" font-size="11" fill="#94a3b8" font-weight="600">0</text>
      <text x="18" y="199" font-size="11" fill="#94a3b8" font-weight="600">-1</text>
    </svg>
  </div>

  <div class="legend">
    <div class="legend-item">
      <div class="legend-line" style="background: #2563eb;"></div>
      <span>Original (fₘₐₓ)</span>
    </div>
    <div class="legend-item">
      <div class="legend-dot"></div>
      <span>Samples (fₛ)</span>
    </div>
    <div class="legend-item">
      <div class="legend-line" style="background: #ef4444; border-top: 2px dashed #ef4444;"></div>
      <span>Reconstructed</span>
    </div>
  </div>

  <script>
    const width = 530; // 570 - 40
    const xOffset = 40;
    const centerY = 115;
    const amp = 80;
    const cycles = 3; // 3 full cycles of original wave across plot

    const origPathEl = document.getElementById('originalPath');
    const aliasPathEl = document.getElementById('aliasPath');
    const samplesGroup = document.getElementById('samplesGroup');
    const rateSlider = document.getElementById('rateSlider');
    const rateLabel = document.getElementById('rateLabel');
    const statusBar = document.getElementById('statusBar');
    const statusFormula = document.getElementById('statusFormula');
    const statusText = document.getElementById('statusText');

    // Generate static original wave
    let origD = '';
    const totalPoints = 300;
    for (let i = 0; i <= totalPoints; i++) {
      const tNorm = i / totalPoints;
      const x = xOffset + tNorm * width;
      const y = centerY - amp * Math.sin(2 * Math.PI * cycles * tNorm);
      origD += (i === 0 ? 'M' : 'L') + `${x.toFixed(1)} ${y.toFixed(1)} `;
    }
    origPathEl.setAttribute('d', origD);

    function update(ratio) {
      rateSlider.value = ratio;
      rateLabel.textContent = ratio.toFixed(2) + '×';

      // Update preset buttons active state
      document.getElementById('btnUnder').classList.toggle('active', Math.abs(ratio - 1.25) < 0.05);
      document.getElementById('btnNyquist').classList.toggle('active', Math.abs(ratio - 2.0) < 0.05);
      document.getElementById('btnOver').classList.toggle('active', Math.abs(ratio - 4.0) < 0.05);

      // Update status message
      if (ratio < 1.95) {
        statusBar.className = 'status-bar status-aliased';
        statusFormula.textContent = `fₛ = ${ratio.toFixed(1)} fₘₐₓ < 2 fₘₐₓ`;
        statusText.textContent = '✗ Aliasing Error (False Frequency)';
      } else if (ratio <= 2.05) {
        statusBar.className = 'status-bar status-nyquist';
        statusFormula.textContent = `fₛ = 2.0 fₘₐₓ (Nyquist Limit)`;
        statusText.textContent = '✦ Theoretical Minimum';
      } else {
        statusBar.className = 'status-bar status-good';
        statusFormula.textContent = `fₛ = ${ratio.toFixed(1)} fₘₐₓ ≥ 2 fₘₐₓ`;
        statusText.textContent = '✓ Faithful Reconstruction';
      }

      // Calculate samples
      const totalSamples = Math.floor(cycles * ratio);
      const sampleDt = 1 / (cycles * ratio);
      let samplesHtml = '';
      const samplePoints = [];

      for (let k = 0; k <= totalSamples; k++) {
        const tNorm = k * sampleDt;
        if (tNorm > 1.0001) break;
        const x = xOffset + tNorm * width;
        const val = Math.sin(2 * Math.PI * cycles * tNorm);
        const y = centerY - amp * val;

        samplePoints.push({ x, y, val, tNorm });

        // Stem lines + Dots
        samplesHtml += `<line x1="${x.toFixed(1)}" y1="${centerY}" x2="${x.toFixed(1)}" y2="${y.toFixed(1)}" stroke="#0f172a" stroke-width="1.5" opacity="0.3"/>`;
        samplesHtml += `<circle cx="${x.toFixed(1)}" cy="${y.toFixed(1)}" r="4.5" fill="#0f172a"/>`;
      }
      samplesGroup.innerHTML = samplesHtml;

      // Reconstructed alias curve
      let aliasD = '';
      if (ratio >= 2.0) {
        // Faithful reproduction matches original
        aliasPathEl.setAttribute('d', origD);
        aliasPathEl.setAttribute('stroke', '#10b981');
      } else {
        // Apparent alias frequency: f_alias = |f_orig - round(f_orig/f_s)*f_s|
        const f_orig = 1.0;
        const fs_val = ratio;
        const kRound = Math.round(f_orig / fs_val);
        const f_apparent = Math.abs(f_orig - kRound * fs_val);
        const apparentCycles = Math.max(0.2, f_apparent * cycles);
        const phaseShift = (f_orig - kRound * fs_val < 0) ? Math.PI : 0;

        for (let i = 0; i <= totalPoints; i++) {
          const tNorm = i / totalPoints;
          const x = xOffset + tNorm * width;
          const y = centerY - amp * Math.sin(2 * Math.PI * apparentCycles * tNorm + phaseShift);
          aliasD += (i === 0 ? 'M' : 'L') + `${x.toFixed(1)} ${y.toFixed(1)} `;
        }
        aliasPathEl.setAttribute('d', aliasD);
        aliasPathEl.setAttribute('stroke', '#ef4444');
      }
    }

    function setRatio(val) {
      update(parseFloat(val));
    }

    rateSlider.addEventListener('input', (e) => {
      update(parseFloat(e.target.value));
    });

    // Initialize
    update(4.0);
  </script>
</body>
</html>

Similarly, because the human ear hears frequencies up to $20\text{ kHz}$, standard audio CDs require a theoretical minimum of $40\text{ kHz}$. They actually use $44.1\text{ kHz}$ so engineering filters have room to cut off gently.

What happens if an engineer samples an analog wave at exactly $2 f_{\text{max}}$ instead of slightly above it?

A common misconception is that sampling at *exactly* $f_s = 2 f_{\text{max}}$ is always foolproof in practical hardware. But if your sample clock aligns precisely with the sine wave's **zero-crossings** (where the voltage crosses $0\text{ V}$), every single sample will read zero!

<!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: system-ui, -apple-system, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      padding: 12px;
      user-select: none;
      -webkit-user-select: none;
    }
    .controls {
      display: flex;
      gap: 8px;
      width: 100%;
      max-width: 540px;
      margin-bottom: 10px;
    }
    .btn {
      flex: 1;
      padding: 8px 6px;
      font-size: 13px;
      font-weight: 600;
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      background: #ffffff;
      color: #1e2945;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 4px;
      box-shadow: 0 1px 2px rgba(0,0,0,0.05);
      transition: all 0.2s ease;
    }
    .btn.active {
      background: #2563eb;
      color: #ffffff;
      border-color: #2563eb;
    }
    .btn.active.warn {
      background: #ef4444;
      border-color: #ef4444;
    }
    .slider-row {
      display: flex;
      align-items: center;
      gap: 10px;
      width: 100%;
      max-width: 540px;
      margin-bottom: 12px;
      font-size: 13px;
      font-weight: 600;
      color: #64748b;
    }
    input[type=range] {
      flex: 1;
      accent-color: #2563eb;
      cursor: pointer;
      height: 6px;
    }
    .graph-card {
      width: 100%;
      max-width: 540px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 12px;
      padding: 12px;
      box-shadow: 0 1px 4px rgba(0,0,0,0.04);
      display: flex;
      flex-direction: column;
      gap: 8px;
    }
    svg {
      width: 100%;
      height: auto;
      display: block;
      overflow: visible;
    }
    .legend {
      display: flex;
      justify-content: space-between;
      align-items: center;
      padding-top: 4px;
      border-top: 1px solid #f1f5f9;
      font-size: 13px;
      font-weight: 600;
    }
    .tag {
      display: inline-flex;
      align-items: center;
      gap: 6px;
    }
    .dot-sample {
      width: 10px;
      height: 10px;
      border-radius: 50%;
      background: #ef4444;
    }
    .badge {
      padding: 3px 8px;
      border-radius: 6px;
      font-size: 12px;
      font-weight: 700;
    }
    .badge-error {
      background: #fee2e2;
      color: #b91c1c;
    }
    .badge-ok {
      background: #dcfce7;
      color: #15803d;
    }
    .badge-attenuated {
      background: #fef3c7;
      color: #b45309;
    }
  </style>
</head>
<body>

  <div class="controls">
    <button id="btnZero" class="btn active warn" onclick="setPhase(0)">Zero-Crossings ⚠️</button>
    <button id="btnPeaks" class="btn" onclick="setPhase(90)">Peaks ✓</button>
  </div>

  <div class="slider-row">
    <span>Phase</span>
    <input type="range" id="phaseSlider" min="0" max="180" value="0" step="1" oninput="onSlide(this.value)">
    <span id="degLabel" style="width: 38px; text-align: right;">0°</span>
  </div>

  <div class="graph-card">
    <svg id="scope" viewBox="0 0 500 200">
      
      <line x1="20" y1="30" x2="480" y2="30" stroke="#f1f5f9" stroke-width="1"/>
      <line x1="20" y1="170" x2="480" y2="170" stroke="#f1f5f9" stroke-width="1"/>
      <line x1="20" y1="100" x2="480" y2="100" stroke="#cbd5e1" stroke-width="1.5" stroke-dasharray="4 4"/>

      
      <text x="25" y="34" font-size="11" fill="#94a3b8" font-weight="600">+1V</text>
      <text x="25" y="104" font-size="11" fill="#94a3b8" font-weight="600"> 0V</text>
      <text x="25" y="174" font-size="11" fill="#94a3b8" font-weight="600">-1V</text>

      
      <path id="analogWave" fill="none" stroke="#2563eb" stroke-width="2.5" opacity="0.35"/>
      <path id="reconstructWave" fill="none" stroke="#ef4444" stroke-width="2" stroke-dasharray="5 5"/>

      
      <g id="sampleGroup"></g>
    </svg>

    <div class="legend">
      <div class="tag">
        <div class="dot-sample" id="dotColor"></div>
        <span>f<sub>s</sub> = 2f<sub>max</sub></span>
      </div>
      <div id="statusBadge" class="badge badge-error">Output: 0 V (Lost)</div>
    </div>
  </div>

  <script>
    const svgAnalog = document.getElementById('analogWave');
    const svgReconstruct = document.getElementById('reconstructWave');
    const sampleGroup = document.getElementById('sampleGroup');
    const slider = document.getElementById('phaseSlider');
    const degLabel = document.getElementById('degLabel');
    const statusBadge = document.getElementById('statusBadge');
    const dotColor = document.getElementById('dotColor');
    const btnZero = document.getElementById('btnZero');
    const btnPeaks = document.getElementById('btnPeaks');

    const W = 460;
    const X0 = 20;
    const Y0 = 100;
    const AMP = 70;
    const CYCLES = 2.5;

    // Build constant continuous sine wave
    let wavePath = '';
    for (let x = 0; x <= W; x += 2) {
      const theta = (x / W) * (CYCLES * 2 * Math.PI);
      const y = Y0 - Math.sin(theta) * AMP;
      wavePath += (x === 0 ? `M ${X0 + x} ${y}` : ` L ${X0 + x} ${y}`);
    }
    svgAnalog.setAttribute('d', wavePath);

    function update(deg) {
      const phaseRad = (deg * Math.PI) / 180;
      degLabel.textContent = `${deg}°`;
      slider.value = deg;

      btnZero.className = (deg === 0) ? 'btn active warn' : 'btn';
      btnPeaks.className = (deg === 90) ? 'btn active' : 'btn';

      // Sampling points: exactly 2 per cycle (spaced by PI in theta)
      sampleGroup.innerHTML = '';
      let reconPath = '';
      const stepTheta = Math.PI; // fs = 2 * f
      const totalTheta = CYCLES * 2 * Math.PI;
      const numSamples = Math.floor((totalTheta - phaseRad) / stepTheta) + 1;

      const sampleAmp = Math.abs(Math.sin(phaseRad + Math.PI / 2)); // peak height sampled

      for (let i = 0; i <= numSamples + 1; i++) {
        const th = phaseRad + i * stepTheta;
        const x = (th / totalTheta) * W;
        if (x < 0 || x > W) continue;

        const val = Math.sin(th);
        const y = Y0 - val * AMP;
        const px = X0 + x;

        // Stem line
        const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
        line.setAttribute('x1', px);
        line.setAttribute('y1', Y0);
        line.setAttribute('x2', px);
        line.setAttribute('y2', y);
        line.setAttribute('stroke', '#ef4444');
        line.setAttribute('stroke-width', '1.5');
        line.setAttribute('opacity', '0.6');
        sampleGroup.appendChild(line);

        // Dot
        const dot = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
        dot.setAttribute('cx', px);
        dot.setAttribute('cy', y);
        dot.setAttribute('r', '4.5');
        dot.setAttribute('fill', '#ef4444');
        sampleGroup.appendChild(dot);

        reconPath += (reconPath === '' ? `M ${px} ${y}` : ` L ${px} ${y}`);
      }

      svgReconstruct.setAttribute('d', reconPath);

      // Status text
      const v = Math.abs(Math.sin(phaseRad)).toFixed(2);
      if (deg === 0 || deg === 180) {
        statusBadge.textContent = 'Output: 0.00 V (Signal Lost!)';
        statusBadge.className = 'badge badge-error';
      } else if (deg === 90) {
        statusBadge.textContent = 'Output: ±1.00 V (Full Peak)';
        statusBadge.className = 'badge badge-ok';
      } else {
        statusBadge.textContent = `Output: ±${v} V (Attenuated)`;
        statusBadge.className = 'badge badge-attenuated';
      }
    }

    function setPhase(deg) {
      update(deg);
    }

    function onSlide(val) {
      update(parseInt(val, 10));
    }

    // Init
    update(0);
  </script>
</body>
</html>

What happens if a high-frequency noise spike exceeds your Nyquist frequency and enters your digital converter anyway?

When an input frequency $f_{\text{in}}$ exceeds the Nyquist limit ($f_s / 2$), it masquerades as a completely different lower frequency called an **alias frequency** ($f_{\text{alias}}$), calculated by: $$f_{\text{alias}} = |f_{\text{in}} - k f_s|$$ where $k$ is an integer chosen so $f_{\text{alias}} \le f_s/2$.

If a microcontroller samples a sensor at $f_s = 100\text{ Hz}$, its Nyquist limit is $50\text{ Hz}$. If a motor introduces an unwanted $80\text{ Hz}$ noise spike, the system records a false ghost signal at $|80 - 100| = 20\text{ Hz}$ that corrupts your valid data.

electronics

The Nyquist-Shannon Sampling Theorem and Minimum Sampling Rates. Determine the minimum required sampling frequency (Nyquist rate) given the highest frequency component of an analogue signal.

Isaac Physics: Signal Processing, Sampling and Communications for A-Level

Khan Academy: Signals and Systems – Sampling Theorem and Discrete-Time Signals

LibreTexts Engineering: The Nyquist-Shannon Sampling Theorem & Signal Reconstruction

Teaching Year 13 (A2 Level) students the Nyquist-Shannon sampling theorem is most effective when balancing mathematical rigor with intuitive physical models. Begin with hands-on auditory or stroboscopic demonstrations (e.g. the 'wagon-wheel effect' in video frames or sweeping a signal generator above $f_s/2$ on an oscilloscope to hear/see lower aliased tones appear). Ensure students consistently practice decomposing multi-frequency waveforms into discrete Fourier components before calculating $f_s$, cementing the rule that the fastest changing component ($f_{\text{max}}$), not the fundamental, governs system sampling constraints.

The Nyquist-Shannon Sampling Theorem and Minimum Sampling Rates

The Nyquist-Shannon Theorem

Worked Examples: Audio & Telecom