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

Imagine a single highway bridge connecting two cities, but dozens of different roads want to cross it at the same time. How do traffic controllers make sure only one designated lane gets access to the bridge at any given moment?

In digital electronics, we solve this with a **multiplexer** (or **MUX**), which is a digital selector switch that routes one of several input signals to a single common output line.

<!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;
      user-select: none;
      -webkit-user-select: none;
    }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      height: 100%;
      min-height: 380px;
      padding: 10px 8px;
    }
    
    /* Top Type Tabs */
    .tabs {
      display: flex;
      gap: 6px;
      background: #e2e8f0;
      padding: 3px;
      border-radius: 8px;
    }
    .tab-btn {
      padding: 4px 14px;
      font-size: 13px;
      font-weight: 700;
      border: none;
      border-radius: 6px;
      background: transparent;
      color: #64748b;
      cursor: pointer;
      transition: all 0.2s ease;
    }
    .tab-btn.active {
      background: #ffffff;
      color: #0284c7;
      box-shadow: 0 1px 4px rgba(0,0,0,0.08);
    }

    /* Main MUX Area */
    .mux-stage {
      position: relative;
      width: 100%;
      max-width: 480px;
      flex: 1;
      display: flex;
      align-items: center;
      justify-content: center;
    }
    svg {
      width: 100%;
      height: 100%;
      max-height: 290px;
      overflow: visible;
    }

    /* Interactive Pin Elements */
    .pin-btn {
      cursor: pointer;
    }
    .pin-btn rect {
      transition: fill 0.2s ease, stroke 0.2s ease;
    }
    .pin-text {
      font-size: 11px;
      font-weight: 700;
      text-anchor: middle;
      dominant-baseline: central;
      pointer-events: none;
    }
    .data-val {
      font-size: 12px;
      font-weight: 800;
      text-anchor: middle;
      dominant-baseline: central;
      pointer-events: none;
    }

    /* Control Panel at Bottom */
    .control-panel {
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 12px;
      background: #ffffff;
      padding: 6px 14px;
      border-radius: 20px;
      box-shadow: 0 2px 8px rgba(0,0,0,0.05);
    }
    .sel-btn-group {
      display: flex;
      align-items: center;
      gap: 6px;
    }
    .sel-toggle {
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 2px;
      cursor: pointer;
    }
    .sel-label {
      font-size: 11px;
      font-weight: 700;
      color: #64748b;
    }
    .bit-pill {
      width: 28px;
      height: 22px;
      background: #f1f5f9;
      border: 1.5px solid #cbd5e1;
      border-radius: 5px;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 13px;
      font-weight: 800;
      color: #64748b;
      transition: all 0.15s ease;
    }
    .bit-pill.active {
      background: #22b7ff;
      border-color: #0284c7;
      color: #ffffff;
      box-shadow: 0 0 8px rgba(34, 183, 255, 0.4);
    }
  </style>
</head>
<body>

  
  <div class="tabs">
    <button class="tab-btn" onclick="setMode(2)">2:1 MUX</button>
    <button class="tab-btn active" onclick="setMode(4)">4:1 MUX</button>
    <button class="tab-btn" onclick="setMode(8)">8:1 MUX</button>
  </div>

  
  <div class="mux-stage">
    <svg id="circuitSvg" viewBox="0 0 400 240"></svg>
  </div>

  
  <div class="control-panel" id="selectPanel"></div>

  <script>
    let mode = 4; // 2, 4, or 8
    let selectVal = 1; // decimal selection
    let dataValues = [1, 0, 1, 0, 1, 0, 1, 0]; // state for inputs D0..D7

    function numSelectBits() {
      return Math.log2(mode);
    }

    function setMode(m) {
      mode = m;
      if (selectVal >= mode) selectVal = 0;
      document.querySelectorAll('.tab-btn').forEach((btn, idx) => {
        btn.classList.toggle('active', (idx === 0 && m===2) || (idx === 1 && m===4) || (idx === 2 && m===8));
      });
      render();
    }

    function toggleSelectBit(bitIdx) {
      selectVal ^= (1 << bitIdx);
      if (selectVal >= mode) selectVal = mode - 1;
      render();
    }

    function toggleDataInput(idx) {
      dataValues[idx] = dataValues[idx] === 1 ? 0 : 1;
      render();
    }

    function selectChannelDirectly(idx) {
      selectVal = idx;
      render();
    }

    function render() {
      const svg = document.getElementById('circuitSvg');
      const numBits = numSelectBits();
      const outputVal = dataValues[selectVal];
      
      // Geometry params
      const muxLeft = 140;
      const muxRight = 260;
      const muxTop = 20;
      const muxBottom = 200;
      const muxMidY = (muxTop + muxBottom) / 2;
      const outPinX = 350;

      let html = '';

      // Trapezoid Body
      const polyPoints = `${muxLeft},${muxTop} ${muxRight},${muxTop + 35} ${muxRight},${muxBottom - 35} ${muxLeft},${muxBottom}`;
      html += `
        <polygon points="${polyPoints}" fill="#ffffff" stroke="#94a3b8" stroke-width="2" stroke-linejoin="round" />
        <text x="${(muxLeft + muxRight) / 2}" y="${muxMidY - 8}" fill="#64748b" font-size="13" font-weight="800" text-anchor="middle">MUX</text>
        <text x="${(muxLeft + muxRight) / 2}" y="${muxMidY + 12}" fill="#94a3b8" font-size="11" font-weight="700" text-anchor="middle">${mode}:1</text>
      `;

      // Inputs (Left)
      const spacing = (muxBottom - muxTop - 24) / (mode - 1 || 1);
      for (let i = 0; i < mode; i++) {
        const y = mode === 1 ? muxMidY : (muxTop + 12) + i * spacing;
        const isSelected = (i === selectVal);
        const val = dataValues[i];
        
        // Active Route Color Logic
        const lineColor = isSelected ? (val ? '#22b7ff' : '#64748b') : '#cbd5e1';
        const lineStrokeWidth = isSelected ? 3.5 : 1.5;
        const btnFill = val ? '#22b7ff' : '#e2e8f0';
        const btnTextColor = val ? '#ffffff' : '#64748b';

        // Wire from button to MUX
        html += `
          <line x1="68" y1="${y}" x2="${muxLeft}" y2="${y}" stroke="${lineColor}" stroke-width="${lineStrokeWidth}" stroke-linecap="round" />
        `;

        // Internal routing dashed line if active
        if (isSelected) {
          html += `
            <path d="M ${muxLeft} ${y} Q ${(muxLeft + muxRight)/2} ${muxMidY} ${muxRight} ${muxMidY}" 
                  fill="none" stroke="${lineColor}" stroke-width="3" stroke-dasharray="4,3" />
          `;
        }

        // Input Pin Button (Click toggles 0/1, tap label selects)
        html += `
          <g class="pin-btn" onclick="toggleDataInput(${i})">
            <rect x="38" y="${y - 10}" width="28" height="20" rx="5" fill="${btnFill}" stroke="${isSelected ? '#0284c7' : '#94a3b8'}" stroke-width="${isSelected ? 2 : 1}" />
            <text class="data-val" x="52" y="${y}" fill="${btnTextColor}">${val}</text>
          </g>
          <text class="pin-text" x="22" y="${y}" fill="${isSelected ? '#0284c7' : '#64748b'}" font-weight="${isSelected ? '800' : '600'}" style="cursor:pointer;" onclick="selectChannelDirectly(${i})">D${i}</text>
        `;
      }

      // Output (Right)
      const outColor = outputVal ? '#22b7ff' : '#64748b';
      html += `
        <line x1="${muxRight}" y1="${muxMidY}" x2="${outPinX}" y2="${muxMidY}" stroke="${outColor}" stroke-width="3.5" stroke-linecap="round" />
        <g>
          <rect x="${outPinX}" y="${muxMidY - 14}" width="34" height="28" rx="6" fill="${outputVal ? '#22b7ff' : '#f1f5f9'}" stroke="${outputVal ? '#0284c7' : '#94a3b8'}" stroke-width="2" />
          <text class="data-val" x="${outPinX + 17}" y="${muxMidY}" fill="${outputVal ? '#ffffff' : '#64748b'}" font-size="14">${outputVal}</text>
          <text class="pin-text" x="${outPinX + 17}" y="${muxMidY + 24}" fill="#0284c7" font-size="12">Y</text>
        </g>
      `;

      // Select lines (Bottom into MUX)
      const selSpacing = 24;
      const selStartX = ((muxLeft + muxRight) / 2) - ((numBits - 1) * selSpacing) / 2;
      for (let b = 0; b < numBits; b++) {
        const sx = selStartX + (numBits - 1 - b) * selSpacing;
        const bitState = (selectVal >> b) & 1;
        const selColor = bitState ? '#22b7ff' : '#cbd5e1';
        
        html += `
          <line x1="${sx}" y1="${muxBottom - 10}" x2="${sx}" y2="230" stroke="${selColor}" stroke-width="2.5" stroke-linecap="round" />
          <text x="${sx}" y="238" fill="#64748b" font-size="10" font-weight="700" text-anchor="middle">S${b}</text>
        `;
      }

      svg.innerHTML = html;

      // Render Bottom Select Bit Pill Controls
      const panel = document.getElementById('selectPanel');
      let panelHtml = '';
      for (let b = numBits - 1; b >= 0; b--) {
        const bitState = (selectVal >> b) & 1;
        panelHtml += `
          <div class="sel-toggle" onclick="toggleSelectBit(${b})">
            <span class="sel-label">S${b}</span>
            <div class="bit-pill ${bitState ? 'active' : ''}">${bitState}</div>
          </div>
        `;
      }
      panel.innerHTML = panelHtml;
    }

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

How does a circuit make this choice using pure logic gates without moving parts?

The simplest MUX is the **2-to-1 multiplexer** ($n=1$), which chooses between two data inputs ($I_0$ and $I_1$) using a single digital control signal called a **select line** ($S_0$).

When $S_0 = 0$, the circuit opens the path for $I_0$; when $S_0 = 1$, it passes $I_1$. This yields the characteristic **Boolean equation** $Y = \overline{S_0} I_0 + S_0 I_1$.

<!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: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
      user-select: none;
    }

    .nav-tabs {
      display: flex;
      gap: 6px;
      background: #e2e8f0;
      padding: 4px;
      border-radius: 10px;
      width: 100%;
      max-width: 440px;
    }
    .tab-btn {
      flex: 1;
      padding: 6px 4px;
      font-size: 14px;
      font-weight: 600;
      border: none;
      background: transparent;
      color: #64748b;
      border-radius: 6px;
      cursor: pointer;
      transition: background 0.2s, color 0.2s, box-shadow 0.2s;
      text-align: center;
    }
    .tab-btn.active {
      background: #ffffff;
      color: #0284c7;
      box-shadow: 0 2px 4px rgba(0,0,0,0.06);
    }

    .circuit-container {
      width: 100%;
      max-width: 440px;
      height: 260px;
      position: relative;
      background: #ffffff;
      border-radius: 12px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.05);
      overflow: hidden;
      margin: 8px 0;
    }

    svg {
      width: 100%;
      height: 100%;
      display: block;
    }

    .wire {
      stroke: #cbd5e1;
      stroke-width: 2.5;
      fill: none;
      stroke-linecap: round;
      transition: stroke 0.25s, stroke-width 0.25s;
    }
    .wire.active {
      stroke: #0284c7;
      stroke-width: 3.5;
    }

    .mux-body {
      fill: #f0f9ff;
      stroke: #0284c7;
      stroke-width: 2;
    }

    .pin-label {
      font-size: 13px;
      font-weight: 600;
      fill: #475569;
      dominant-baseline: central;
    }
    .pin-label.active {
      fill: #0284c7;
      font-weight: 700;
    }

    .out-label {
      font-size: 15px;
      font-weight: 700;
      fill: #0284c7;
      dominant-baseline: central;
    }

    .controls-row {
      display: flex;
      align-items: center;
      justify-content: space-between;
      width: 100%;
      max-width: 440px;
      background: #ffffff;
      border-radius: 10px;
      padding: 8px 12px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.05);
      gap: 8px;
    }

    .select-group {
      display: flex;
      align-items: center;
      gap: 6px;
    }
    .select-title {
      font-size: 13px;
      font-weight: 600;
      color: #64748b;
    }

    .bit-btn {
      display: inline-flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      min-width: 34px;
      height: 34px;
      border: 1.5px solid #cbd5e1;
      background: #f8fafc;
      border-radius: 6px;
      cursor: pointer;
      font-size: 13px;
      font-weight: 700;
      color: #1e2945;
      padding: 0 4px;
      line-height: 1;
    }
    .bit-btn span {
      font-size: 10px;
      color: #64748b;
      font-weight: 500;
      margin-top: 1px;
    }
    .bit-btn.high {
      background: #e0f2fe;
      border-color: #0284c7;
      color: #0284c7;
    }

    .formula-tag {
      font-size: 13px;
      font-weight: 600;
      color: #0f172a;
      background: #f1f5f9;
      padding: 6px 10px;
      border-radius: 6px;
      white-space: nowrap;
    }
    .formula-tag span {
      color: #0284c7;
      font-weight: 700;
    }
  </style>
</head>
<body>

  
  <div class="nav-tabs">
    <button class="tab-btn active" id="tab2" onclick="setMode(2)">2-to-1</button>
    <button class="tab-btn" id="tab4" onclick="setMode(4)">4-to-1</button>
    <button class="tab-btn" id="tab8" onclick="setMode(8)">8-to-1</button>
  </div>

  
  <div class="circuit-container">
    <svg viewBox="0 0 380 230" id="svgArea">
      
      <polygon points="140,25 240,55 240,175 140,205" class="mux-body" />
      <text x="190" y="115" text-anchor="middle" dominant-baseline="central" fill="#0369a1" font-size="16" font-weight="700">MUX</text>

      
      <g id="wiresGroup"></g>
      <g id="selectWiresGroup"></g>
      <g id="labelsGroup"></g>
      <g id="switchArmGroup"></g>
    </svg>
  </div>

  
  <div class="controls-row">
    <div class="select-group">
      <span class="select-title">Select:</span>
      <div id="selectBtns" style="display: flex; gap: 4px;"></div>
    </div>
    <div class="formula-tag" id="formulaTag">
      2<sup>k</sup> = 2<sup>1</sup> → <span>2 Inputs</span>
    </div>
  </div>

  <script>
    let currentMode = 2; // 2, 4, 8
    let selectValues = [0, 0, 0]; // S2, S1, S0

    function setMode(n) {
      currentMode = n;
      selectValues = [0, 0, 0];
      
      document.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
      document.getElementById('tab' + n).classList.add('active');

      const k = Math.log2(n);
      document.getElementById('formulaTag').innerHTML = `2<sup>k</sup> = 2<sup>${k}</sup> → <span>${n} Inputs</span>`;
      
      renderControls();
      renderCircuit();
    }

    function toggleBit(bitIdx) {
      selectValues[bitIdx] = selectValues[bitIdx] === 0 ? 1 : 0;
      renderControls();
      renderCircuit();
    }

    function getSelectedInputIndex() {
      const k = Math.log2(currentMode);
      if (k === 1) return selectValues[0];
      if (k === 2) return (selectValues[1] << 1) | selectValues[0];
      return (selectValues[2] << 2) | (selectValues[1] << 1) | selectValues[0];
    }

    function renderControls() {
      const k = Math.log2(currentMode);
      const container = document.getElementById('selectBtns');
      container.innerHTML = '';

      for (let i = k - 1; i >= 0; i--) {
        const val = selectValues[i];
        const btn = document.createElement('button');
        btn.className = `bit-btn ${val === 1 ? 'high' : ''}`;
        btn.innerHTML = `${val}<span>S<sub>${i}</sub></span>`;
        btn.onclick = () => toggleBit(i);
        container.appendChild(btn);
      }
    }

    function renderCircuit() {
      const n = currentMode;
      const k = Math.log2(n);
      const selIdx = getSelectedInputIndex();

      const wiresGroup = document.getElementById('wiresGroup');
      const selectWiresGroup = document.getElementById('selectWiresGroup');
      const labelsGroup = document.getElementById('labelsGroup');
      const switchArmGroup = document.getElementById('switchArmGroup');

      wiresGroup.innerHTML = '';
      selectWiresGroup.innerHTML = '';
      labelsGroup.innerHTML = '';
      switchArmGroup.innerHTML = '';

      // Calculate input Y positions
      const yStart = 40;
      const yEnd = 190;
      const step = n === 1 ? 0 : (yEnd - yStart) / (n - 1);

      let activeInY = 0;

      for (let i = 0; i < n; i++) {
        const y = n === 1 ? 115 : yStart + i * step;
        const isActive = (i === selIdx);
        if (isActive) activeInY = y;

        // Input Wire
        const path = document.createElementNS("http://www.w3.org/2000/svg", "line");
        path.setAttribute("x1", "55");
        path.setAttribute("y1", y);
        path.setAttribute("x2", "140");
        path.setAttribute("y2", y);
        path.setAttribute("class", `wire ${isActive ? 'active' : ''}`);
        wiresGroup.appendChild(path);

        // Input Terminal Point
        const dot = document.createElementNS("http://www.w3.org/2000/svg", "circle");
        dot.setAttribute("cx", "140");
        dot.setAttribute("cy", y);
        dot.setAttribute("r", "3");
        dot.setAttribute("fill", isActive ? "#0284c7" : "#94a3b8");
        wiresGroup.appendChild(dot);

        // Input Label
        const txt = document.createElementNS("http://www.w3.org/2000/svg", "text");
        txt.setAttribute("x", "48");
        txt.setAttribute("y", y);
        txt.setAttribute("text-anchor", "end");
        txt.setAttribute("class", `pin-label ${isActive ? 'active' : ''}`);
        txt.textContent = `I${i}`;
        labelsGroup.appendChild(txt);
      }

      // Output Wire & Label
      const outY = 115;
      const outWire = document.createElementNS("http://www.w3.org/2000/svg", "line");
      outWire.setAttribute("x1", "240");
      outWire.setAttribute("y1", outY);
      outWire.setAttribute("x2", "315");
      outWire.setAttribute("y2", outY);
      outWire.setAttribute("class", "wire active");
      wiresGroup.appendChild(outWire);

      const outDot = document.createElementNS("http://www.w3.org/2000/svg", "circle");
      outDot.setAttribute("cx", "240");
      outDot.setAttribute("cy", outY);
      outDot.setAttribute("r", "3.5");
      outDot.setAttribute("fill", "#0284c7");
      wiresGroup.appendChild(outDot);

      const outTxt = document.createElementNS("http://www.w3.org/2000/svg", "text");
      outTxt.setAttribute("x", "325");
      outTxt.setAttribute("y", outY);
      outTxt.setAttribute("class", "out-label");
      outTxt.textContent = `Y = I${selIdx}`;
      labelsGroup.appendChild(outTxt);

      // Internal connection line (multiplexer channel routing)
      const routeLine = document.createElementNS("http://www.w3.org/2000/svg", "path");
      routeLine.setAttribute("d", `M 140 ${activeInY} C 180 ${activeInY}, 200 ${outY}, 240 ${outY}`);
      routeLine.setAttribute("fill", "none");
      routeLine.setAttribute("stroke", "#0284c7");
      routeLine.setAttribute("stroke-width", "3");
      routeLine.setAttribute("stroke-dasharray", "4,2");
      switchArmGroup.appendChild(routeLine);

      // Select lines entering bottom of MUX
      const sXStart = 175 - (k - 1) * 12;
      for (let i = 0; i < k; i++) {
        const sX = sXStart + i * 24;
        const val = selectValues[i];

        const sWire = document.createElementNS("http://www.w3.org/2000/svg", "line");
        sWire.setAttribute("x1", sX);
        sWire.setAttribute("y1", "225");
        sWire.setAttribute("x2", sX);
        sWire.setAttribute("y2", "190");
        sWire.setAttribute("class", `wire ${val === 1 ? 'active' : ''}`);
        selectWiresGroup.appendChild(sWire);

        const sDot = document.createElementNS("http://www.w3.org/2000/svg", "circle");
        sDot.setAttribute("cx", sX);
        sDot.setAttribute("cy", "190");
        sDot.setAttribute("r", "2.5");
        sDot.setAttribute("fill", val === 1 ? "#0284c7" : "#94a3b8");
        selectWiresGroup.appendChild(sDot);

        const sLbl = document.createElementNS("http://www.w3.org/2000/svg", "text");
        sLbl.setAttribute("x", sX);
        sLbl.setAttribute("y", "218");
        sLbl.setAttribute("text-anchor", "middle");
        sLbl.setAttribute("class", `pin-label ${val === 1 ? 'active' : ''}`);
        sLbl.setAttribute("style", "font-size: 11px;");
        sLbl.textContent = `S${i}`;
        labelsGroup.appendChild(sLbl);
      }
    }

    // Initialize
    setMode(2);
  </script>
</body>
</html>

What happens when our system has four, eight, or even sixteen separate data sources to choose from?

## Address Line Scaling and the 4-to-1 MUX

To select among $N$ input lines, you need $n$ binary **select lines** (also called **address lines**) such that $2^n = N$. Because each binary bit can represent two states ($0$ or $1$), $n$ bits produce $2^n$ unique combinations.

For a **4-to-1 multiplexer** ($n=2$), two select lines ($S_1, S_0$) route four data inputs ($I_0, I_1, I_2, I_3$) according to $Y = \overline{S_1}\overline{S_0}I_0 + \overline{S_1}S_0 I_1 + S_1\overline{S_0}I_2 + S_1 S_0 I_3$.

<!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 {
      width: 100%;
      min-height: 100%;
      background: #f8f9fa;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      padding: 12px;
      user-select: none;
      -webkit-user-select: none;
    }

    /* Mode Navigation */
    .mode-nav {
      display: flex;
      gap: 6px;
      background: #ffffff;
      padding: 4px;
      border-radius: 10px;
      border: 1px solid #e2e8f0;
      margin-bottom: 12px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
    }
    .mode-btn {
      border: none;
      background: transparent;
      padding: 6px 14px;
      border-radius: 7px;
      font-size: 14px;
      font-weight: 700;
      color: #64748b;
      cursor: pointer;
      transition: all 0.2s ease;
    }
    .mode-btn.active {
      background: #22b7ff;
      color: #ffffff;
      box-shadow: 0 2px 6px rgba(34, 183, 255, 0.35);
    }

    /* Main Diagram Container */
    .mux-stage {
      position: relative;
      width: 100%;
      max-width: 580px;
      height: 320px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 14px;
      box-shadow: 0 4px 16px rgba(0,0,0,0.03);
      display: flex;
      align-items: center;
      justify-content: space-between;
      padding: 16px 20px;
      overflow: hidden;
    }

    /* SVG Schematic Layer */
    .schematic-svg {
      position: absolute;
      inset: 0;
      width: 100%;
      height: 100%;
      pointer-events: none;
    }

    /* Left Input Column */
    .inputs-col {
      display: flex;
      flex-direction: column;
      justify-content: space-around;
      height: 100%;
      z-index: 2;
      padding: 6px 0;
    }
    .input-row {
      display: flex;
      align-items: center;
      gap: 6px;
    }
    .input-tag {
      font-size: 13px;
      font-weight: 700;
      color: #64748b;
      width: 22px;
      text-align: right;
    }
    .val-toggle {
      width: 28px;
      height: 28px;
      border-radius: 6px;
      border: 1.5px solid #cbd5e1;
      background: #f1f5f9;
      color: #475569;
      font-size: 14px;
      font-weight: 800;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      transition: all 0.15s ease;
    }
    .val-toggle.high {
      background: #e0f2fe;
      border-color: #0284c7;
      color: #0284c7;
    }
    .input-row.selected .input-tag {
      color: #0284c7;
    }
    .input-row.selected .val-toggle {
      box-shadow: 0 0 0 2px #22b7ff;
    }

    /* Center MUX Block */
    .mux-body {
      position: relative;
      z-index: 1;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      font-weight: 800;
      font-size: 18px;
      color: #0f172a;
    }

    /* Select Controls (Bottom of MUX) */
    .select-panel {
      position: absolute;
      bottom: 12px;
      left: 50%;
      transform: translateX(-50%);
      display: flex;
      align-items: center;
      gap: 12px;
      z-index: 3;
      background: #f8fafc;
      padding: 6px 12px;
      border-radius: 8px;
      border: 1px solid #e2e8f0;
    }
    .select-item {
      display: flex;
      align-items: center;
      gap: 4px;
    }
    .select-name {
      font-size: 13px;
      font-weight: 700;
      color: #64748b;
    }
    .select-btn {
      width: 26px;
      height: 26px;
      border-radius: 5px;
      border: 1.5px solid #94a3b8;
      background: #ffffff;
      color: #0f172a;
      font-size: 13px;
      font-weight: 800;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      transition: all 0.15s ease;
    }
    .select-btn.active-1 {
      background: #22b7ff;
      border-color: #0284c7;
      color: #ffffff;
    }

    /* Output Section */
    .output-col {
      display: flex;
      align-items: center;
      gap: 8px;
      z-index: 2;
    }
    .output-display {
      width: 44px;
      height: 44px;
      border-radius: 10px;
      border: 2px solid #22b7ff;
      background: #f0f9ff;
      color: #0284c7;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 22px;
      font-weight: 800;
      box-shadow: 0 4px 12px rgba(34, 183, 255, 0.2);
      transition: all 0.2s ease;
    }
    .output-label {
      font-size: 16px;
      font-weight: 800;
      color: #1e2945;
    }

    /* SVG dynamic wires */
    .wire-base {
      stroke: #cbd5e1;
      stroke-width: 2.5;
      fill: none;
      stroke-linecap: round;
      stroke-linejoin: round;
    }
    .wire-active {
      stroke: #0284c7;
      stroke-width: 3.5;
      fill: none;
      stroke-linecap: round;
      stroke-linejoin: round;
      transition: d 0.25s ease;
    }
  </style>
</head>
<body>

  
  <div class="mode-nav">
    <button class="mode-btn" onclick="setMode(2)">2-to-1</button>
    <button class="mode-btn active" onclick="setMode(4)">4-to-1</button>
    <button class="mode-btn" onclick="setMode(8)">8-to-1</button>
  </div>

  
  <div class="mux-stage" id="stage">
    <svg class="schematic-svg" id="svgCanvas"></svg>

    
    <div class="inputs-col" id="inputsCol"></div>

    
    <div class="mux-body">
      <div id="muxTitle">4:1 MUX</div>
    </div>

    
    <div class="select-panel" id="selectPanel"></div>

    
    <div class="output-col" id="outputCol">
      <div class="output-label">Y</div>
      <div class="output-display" id="outVal">0</div>
    </div>
  </div>

  <script>
    let mode = 4;
    let selects = [0, 0]; // S1, S0 (or S2, S1, S0)
    let inputs = [0, 1, 0, 1, 0, 0, 1, 1];

    function setMode(m) {
      mode = m;
      document.querySelectorAll('.mode-btn').forEach(btn => {
        btn.classList.toggle('active', btn.textContent.startsWith(m + '-to-1'));
      });
      const numS = Math.log2(mode);
      selects = new Array(numS).fill(0);
      renderUI();
    }

    function toggleSelect(idx) {
      selects[idx] = selects[idx] === 1 ? 0 : 1;
      updateState();
    }

    function toggleInput(idx) {
      inputs[idx] = inputs[idx] === 1 ? 0 : 1;
      updateState();
    }

    function getActiveChannel() {
      let ch = 0;
      for (let i = 0; i < selects.length; i++) {
        ch = (ch << 1) | selects[i];
      }
      return ch;
    }

    function renderUI() {
      document.getElementById('muxTitle').textContent = mode + ':1 MUX';

      // Render Inputs
      const inCol = document.getElementById('inputsCol');
      inCol.innerHTML = '';
      for (let i = 0; i < mode; i++) {
        const row = document.createElement('div');
        row.className = 'input-row';
        row.id = `in-row-${i}`;
        row.innerHTML = `
          <span class="input-tag">I<sub>${i}</sub></span>
          <button class="val-toggle ${inputs[i] ? 'high' : ''}" onclick="toggleInput(${i})">${inputs[i]}</button>
        `;
        inCol.appendChild(row);
      }

      // Render Selects
      const selPanel = document.getElementById('selectPanel');
      selPanel.innerHTML = '';
      for (let i = 0; i < selects.length; i++) {
        const sIndex = selects.length - 1 - i;
        const item = document.createElement('div');
        item.className = 'select-item';
        item.innerHTML = `
          <span class="select-name">S<sub>${sIndex}</sub></span>
          <button class="select-btn ${selects[i] ? 'active-1' : ''}" onclick="toggleSelect(${i})">${selects[i]}</button>
        `;
        selPanel.appendChild(item);
      }

      updateState();
    }

    function updateState() {
      const activeCh = getActiveChannel();
      const outBit = inputs[activeCh];

      // Update Input Rows Highlight
      for (let i = 0; i < mode; i++) {
        const row = document.getElementById(`in-row-${i}`);
        if (row) {
          row.classList.toggle('selected', i === activeCh);
          const btn = row.querySelector('.val-toggle');
          btn.textContent = inputs[i];
          btn.className = `val-toggle ${inputs[i] ? 'high' : ''}`;
        }
      }

      // Update Select Buttons
      const selBtns = document.querySelectorAll('.select-btn');
      selects.forEach((val, idx) => {
        if (selBtns[idx]) {
          selBtns[idx].textContent = val;
          selBtns[idx].className = `select-btn ${val ? 'active-1' : ''}`;
        }
      });

      // Update Output Display
      const outEl = document.getElementById('outVal');
      outEl.textContent = outBit;
      outEl.style.backgroundColor = outBit ? '#e0f2fe' : '#f8fafc';
      outEl.style.borderColor = outBit ? '#0284c7' : '#94a3b8';
      outEl.style.color = outBit ? '#0284c7' : '#64748b';

      drawCircuit(activeCh);
    }

    function drawCircuit(activeCh) {
      const stage = document.getElementById('stage').getBoundingClientRect();
      const svg = document.getElementById('svgCanvas');
      if (!stage.width || !stage.height) return;

      const w = stage.width;
      const h = stage.height;

      // MUX Trapezoid Bounds
      const mx1 = w * 0.38;
      const mx2 = w * 0.62;
      const myTop = h * 0.14;
      const myBottom = h * 0.82;
      const myMid = (myTop + myBottom) / 2;

      let svgHtml = `
        <defs>
          <filter id="glow" x="-20%" y="-20%" width="140%" height="140%">
            <feDropShadow dx="0" dy="1" stdDeviation="3" flood-color="#0284c7" flood-opacity="0.3"/>
          </filter>
        </defs>
        
        <polygon points="${mx1},${myTop} ${mx2},${myTop + 24} ${mx2},${myBottom - 24} ${mx1},${myBottom}" 
                 fill="#ffffff" stroke="#94a3b8" stroke-width="2" stroke-linejoin="round" />
      `;

      // Inputs Lines
      let activeInputY = 0;
      for (let i = 0; i < mode; i++) {
        const row = document.getElementById(`in-row-${i}`);
        if (!row) continue;
        const rRect = row.getBoundingClientRect();
        const y = rRect.top - stage.top + rRect.height / 2;
        const x1 = rRect.right - stage.left + 4;
        const x2 = mx1;

        if (i === activeCh) {
          activeInputY = y;
        } else {
          svgHtml += `<line class="wire-base" x1="${x1}" y1="${y}" x2="${x2}" y2="${y}" />`;
        }
      }

      // Output Line
      const outRow = document.getElementById('outputCol').getBoundingClientRect();
      const outX = outRow.left - stage.left;
      const outY = myMid;
      svgHtml += `<line class="wire-base" x1="${mx2}" y1="${outY}" x2="${outX}" y2="${outY}" />`;

      // Active Connected Path
      if (activeInputY > 0) {
        const activePath = `M ${mx1 - 25} ${activeInputY} L ${mx1} ${activeInputY} L ${mx2} ${outY} L ${outX} ${outY}`;
        svgHtml += `
          <path d="${activePath}" class="wire-active" filter="url(#glow)" />
          <circle cx="${mx2}" cy="${outY}" r="4" fill="#0284c7" />
          <circle cx="${mx1}" cy="${activeInputY}" r="4" fill="#0284c7" />
        `;
      }

      svg.innerHTML = svgHtml;
    }

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

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

For an **8-to-1 multiplexer** ($n=3$), three select lines ($S_2, S_1, S_0$) address eight data inputs ($I_0$ through $I_7$) using minterm decoding: $Y = \sum_{k=0}^7 m_k I_k$, where $m_k$ represents the **minterm** corresponding to binary value $k$.

<!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; }
    html, body {
      width: 100%;
      height: 100%;
      background: #f8f9fa;
      font-family: system-ui, -apple-system, sans-serif;
      color: #1e2945;
      user-select: none;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      padding: 10px 8px;
    }

    .toolbar {
      display: flex;
      gap: 6px;
      width: 100%;
      max-width: 460px;
      justify-content: center;
    }

    .mode-btn {
      flex: 1;
      padding: 6px 0;
      background: #ffffff;
      border: 1px solid #d1d5db;
      border-radius: 8px;
      font-size: 13px;
      font-weight: 700;
      color: #4b5563;
      cursor: pointer;
      box-shadow: 0 1px 2px rgba(0,0,0,0.05);
      transition: all 0.2s ease;
    }

    .mode-btn.active {
      background: #0284c7;
      color: #ffffff;
      border-color: #0284c7;
      box-shadow: 0 2px 6px rgba(2,132,199,0.3);
    }

    .stage {
      width: 100%;
      max-width: 480px;
      flex: 1;
      min-height: 230px;
      display: flex;
      align-items: center;
      justify-content: center;
    }

    svg {
      width: 100%;
      height: 100%;
      max-height: 280px;
      overflow: visible;
    }

    .controls-panel {
      display: flex;
      gap: 12px;
      align-items: center;
      justify-content: center;
      width: 100%;
      max-width: 460px;
      background: #ffffff;
      border: 1px solid #e5e7eb;
      border-radius: 10px;
      padding: 6px 12px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
    }

    .sel-group {
      display: flex;
      gap: 6px;
      align-items: center;
    }

    .bit-toggle {
      display: flex;
      flex-direction: column;
      align-items: center;
      cursor: pointer;
      background: #f1f5f9;
      border: 1px solid #cbd5e1;
      border-radius: 6px;
      padding: 3px 8px;
      min-width: 38px;
      transition: all 0.15s ease;
    }

    .bit-toggle:hover {
      border-color: #0284c7;
    }

    .bit-label {
      font-size: 10px;
      font-weight: 700;
      color: #64748b;
      line-height: 1;
    }

    .bit-val {
      font-size: 15px;
      font-weight: 800;
      color: #0f172a;
      line-height: 1.2;
    }

    .bit-val.hi {
      color: #0284c7;
    }

    .formula-tag {
      font-size: 13px;
      font-weight: 700;
      color: #334155;
      font-family: ui-monospace, monospace;
      padding-left: 8px;
      border-left: 1px solid #e2e8f0;
    }

    /* SVG Interactive Elements */
    .input-node {
      cursor: pointer;
    }
    .input-node:hover circle {
      stroke: #0284c7;
      stroke-width: 2px;
    }
  </style>
</head>
<body>

  <div class="toolbar">
    <button class="mode-btn" data-n="2">2 : 1</button>
    <button class="mode-btn" data-n="4">4 : 1</button>
    <button class="mode-btn active" data-n="8">8 : 1</button>
  </div>

  <div class="stage">
    <svg id="muxSvg" viewBox="0 0 460 260"></svg>
  </div>

  <div class="controls-panel">
    <div class="sel-group" id="selectToggles"></div>
    <div class="formula-tag" id="statusFormula">Y = I<sub>0</sub></div>
  </div>

  <script>
    let mode = 8;
    let selects = [0, 0, 0]; // S2, S1, S0
    let inputs = [1, 0, 1, 1, 0, 1, 0, 0];

    const svg = document.getElementById('muxSvg');
    const selectContainer = document.getElementById('selectToggles');
    const statusFormula = document.getElementById('statusFormula');
    const modeBtns = document.querySelectorAll('.mode-btn');

    function getActiveIndex() {
      let numSel = Math.log2(mode);
      let idx = 0;
      for (let i = 0; i < numSel; i++) {
        let bit = selects[3 - numSel + i];
        idx = (idx << 1) | bit;
      }
      return idx;
    }

    function toggleInput(i) {
      inputs[i] = inputs[i] === 1 ? 0 : 1;
      render();
    }

    function toggleSelect(sIdx) {
      selects[sIdx] = selects[sIdx] === 1 ? 0 : 1;
      render();
    }

    function setMode(n) {
      mode = n;
      modeBtns.forEach(btn => {
        btn.classList.toggle('active', parseInt(btn.dataset.n) === mode);
      });
      render();
    }

    modeBtns.forEach(btn => {
      btn.addEventListener('click', () => setMode(parseInt(btn.dataset.n)));
    });

    function render() {
      const numSel = Math.log2(mode);
      const activeIdx = getActiveIndex();
      const outVal = inputs[activeIdx];

      // Update Controls
      selectContainer.innerHTML = '';
      for (let i = 0; i < numSel; i++) {
        const globalIdx = 3 - numSel + i;
        const selName = `S${numSel - 1 - i}`;
        const val = selects[globalIdx];
        const toggle = document.createElement('div');
        toggle.className = 'bit-toggle';
        toggle.onclick = () => toggleSelect(globalIdx);
        toggle.innerHTML = `
          <span class="bit-label">${selName}</span>
          <span class="bit-val ${val ? 'hi' : ''}">${val}</span>
        `;
        selectContainer.appendChild(toggle);
      }

      statusFormula.innerHTML = `Y = I<sub>${activeIdx}</sub> = <b>${outVal}</b>`;

      // Draw SVG
      const muxLeft = 140, muxRight = 310;
      const muxTop = 20, muxBottom = 230;
      const muxMidY = (muxTop + muxBottom) / 2;
      const outX = 420;

      let html = `
        <defs>
          <filter id="glow" x="-20%" y="-20%" width="140%" height="140%">
            <feDropShadow dx="0" dy="0" stdDeviation="3" flood-color="#0284c7" flood-opacity="0.6"/>
          </filter>
        </defs>

        
        <polygon points="${muxLeft},${muxTop} ${muxRight},${muxTop + 35} ${muxRight},${muxBottom - 35} ${muxLeft},${muxBottom}" 
                 fill="#ffffff" stroke="#94a3b8" stroke-width="2" />
        <text x="${(muxLeft + muxRight) / 2}" y="${muxMidY + 5}" 
              text-anchor="middle" font-size="15" font-weight="800" fill="#cbd5e1" letter-spacing="2">
          ${mode}:1 MUX
        </text>
      `;

      // Select lines into bottom of MUX
      const selSpacing = 30;
      const selStartX = (muxLeft + muxRight) / 2 - ((numSel - 1) * selSpacing) / 2;

      for (let i = 0; i < numSel; i++) {
        const globalIdx = 3 - numSel + i;
        const sx = selStartX + i * selSpacing;
        const val = selects[globalIdx];
        const strokeCol = val ? '#0284c7' : '#94a3b8';
        const strokeW = val ? 2.5 : 1.5;
        const bottomY = muxBottom - ((sx - muxLeft) / (muxRight - muxLeft)) * 35;

        html += `
          <line x1="${sx}" y1="250" x2="${sx}" y2="${bottomY}" stroke="${strokeCol}" stroke-width="${strokeW}" />
          <circle cx="${sx}" cy="250" r="3" fill="${strokeCol}" />
        `;
      }

      // Input lines and nodes
      const inSpacing = (muxBottom - muxTop - 24) / (mode - 1 || 1);
      const startInY = muxTop + 12;
      let activeInY = startInY;

      for (let i = 0; i < mode; i++) {
        const iy = mode === 1 ? muxMidY : startInY + i * inSpacing;
        const isActive = (i === activeIdx);
        const bitVal = inputs[i];
        if (isActive) activeInY = iy;

        const lineCol = isActive ? '#0284c7' : '#cbd5e1';
        const lineW = isActive ? 3 : 1.5;
        const filterStr = isActive ? 'filter="url(#glow)"' : '';

        html += `
          
          <line x1="60" y1="${iy}" x2="${muxLeft}" y2="${iy}" stroke="${lineCol}" stroke-width="${lineW}" ${filterStr} />
          
          
          <g class="input-node" onclick="toggleInput(${i})">
            <rect x="22" y="${iy - 10}" width="34" height="20" rx="10" fill="${bitVal ? '#e0f2fe' : '#f1f5f9'}" stroke="${bitVal ? '#0284c7' : '#94a3b8'}" stroke-width="1.5" />
            <text x="39" y="${iy + 4}" text-anchor="middle" font-size="11" font-weight="800" fill="${bitVal ? '#0284c7' : '#475569'}">${bitVal}</text>
            <text x="14" y="${iy + 3.5}" text-anchor="end" font-size="10" font-weight="700" fill="#64748b">I${i}</text>
          </g>
        `;
      }

      // Internal connection path (Active Switch)
      html += `
        <line x1="${muxLeft}" y1="${activeInY}" x2="${muxRight}" y2="${muxMidY}" 
              stroke="#0284c7" stroke-width="3" stroke-linecap="round" filter="url(#glow)" />
        <circle cx="${muxLeft}" cy="${activeInY}" r="4" fill="#0284c7" />
        <circle cx="${muxRight}" cy="${muxMidY}" r="4" fill="#0284c7" />
      `;

      // Output line & indicator
      html += `
        <line x1="${muxRight}" y1="${muxMidY}" x2="${outX - 18}" y2="${muxMidY}" stroke="#0284c7" stroke-width="3" filter="url(#glow)" />
        <g>
          <rect x="${outX - 16}" y="${muxMidY - 14}" width="42" height="28" rx="8" 
                fill="${outVal ? '#0284c7' : '#64748b'}" />
          <text x="${outX + 5}" y="${muxMidY + 5}" text-anchor="middle" font-size="15" font-weight="800" fill="#ffffff">${outVal}</text>
          <text x="${outX + 5}" y="${muxMidY - 18}" text-anchor="middle" font-size="11" font-weight="800" fill="#1e2945">Y</text>
        </g>
      `;

      svg.innerHTML = html;
    }

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

What happens if we need to completely shut down the output or combine multiple MUX chips to handle even larger data buses?

Real-world integrated circuit multiplexers include an **enable input** (denoted as $\text{EN}$ or $\overline{E}$), which acts as a master on/off switch for the entire chip.

Most industrial logic chips use an **active-low** enable (written with an overbar $\overline{E}$ or an inversion bubble), meaning the chip is operational only when $\overline{E} = 0$. When $\overline{E} = 1$, the output is forced to logic $0$ (or disconnected) regardless of what the select lines or data inputs are doing.

<!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: center;
      min-height: 100vh;
      user-select: none;
    }

    .mux-container {
      width: 100%;
      max-width: 540px;
      display: flex;
      flex-direction: column;
      gap: 12px;
    }

    /* Controls bar */
    .controls {
      display: flex;
      justify-content: space-around;
      align-items: center;
      background: #ffffff;
      padding: 10px 14px;
      border-radius: 12px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.06);
      border: 1px solid #e2e8f0;
      flex-wrap: wrap;
      gap: 8px;
    }

    .ctrl-group {
      display: flex;
      align-items: center;
      gap: 6px;
      font-size: 14px;
      font-weight: 600;
    }

    .btn-toggle {
      width: 38px;
      height: 32px;
      border-radius: 8px;
      border: 1px solid #cbd5e1;
      background: #f1f5f9;
      color: #475569;
      font-weight: 700;
      font-size: 14px;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      transition: all 0.2s ease;
    }
    .btn-toggle.active {
      background: #22b7ff;
      border-color: #0ea5e9;
      color: #ffffff;
      box-shadow: 0 0 8px rgba(34, 183, 255, 0.4);
    }
    .btn-toggle.disabled-en {
      background: #ef4444;
      border-color: #dc2626;
      color: #ffffff;
    }

    /* Interactive circuit diagram area */
    .circuit-box {
      background: #ffffff;
      border-radius: 12px;
      border: 1px solid #e2e8f0;
      box-shadow: 0 1px 3px rgba(0,0,0,0.06);
      padding: 12px;
      position: relative;
    }

    svg {
      width: 100%;
      height: auto;
      display: block;
    }

    /* Interactive svg pins */
    .input-btn {
      cursor: pointer;
      transition: transform 0.15s ease;
    }
    .input-btn:hover {
      filter: brightness(0.95);
    }

    .wire {
      fill: none;
      stroke: #cbd5e1;
      stroke-width: 3;
      stroke-linecap: round;
      stroke-linejoin: round;
      transition: stroke 0.25s ease, stroke-width 0.25s ease;
    }
    .wire.active-high {
      stroke: #22b7ff;
      stroke-width: 4;
    }
    .wire.active-low {
      stroke: #64748b;
      stroke-width: 4;
    }
    .wire.selected {
      stroke: #0284c7;
      stroke-dasharray: 6 3;
      animation: dash 1s linear infinite;
    }
    @keyframes dash {
      to { stroke-dashoffset: -18; }
    }

    .status-pill {
      display: inline-flex;
      align-items: center;
      gap: 6px;
      padding: 4px 10px;
      border-radius: 20px;
      font-size: 13px;
      font-weight: 600;
      background: #f1f5f9;
    }
  </style>
</head>
<body>

<div class="mux-container">
  
  <div class="controls">
    <div class="ctrl-group">
      <span>E&#773; :</span>
      <button id="btnE" class="btn-toggle" onclick="toggleEnable()">0</button>
    </div>
    <div style="width: 1px; height: 24px; background: #e2e8f0;"></div>
    <div class="ctrl-group">
      <span>S&#8321;:</span>
      <button id="btnS1" class="btn-toggle" onclick="toggleS(1)">0</button>
      <span>S&#8320;:</span>
      <button id="btnS0" class="btn-toggle" onclick="toggleS(0)">0</button>
    </div>
    <div style="width: 1px; height: 24px; background: #e2e8f0;"></div>
    <div class="status-pill" id="statusPill">
      Channel: <strong id="channelLabel" style="color:#0284c7">I₀</strong>
    </div>
  </div>

  
  <div class="circuit-box">
    <svg viewBox="0 0 460 270">
      <defs>
        <filter id="glow" x="-20%" y="-20%" width="140%" height="140%">
          <feGaussianBlur stdDeviation="3" result="glow"/>
          <feComposite in="SourceGraphic" in2="glow" operator="over"/>
        </filter>
      </defs>

      
      
      <polygon points="160,30 310,70 310,200 160,240" fill="#f8fafc" stroke="#334155" stroke-width="2.5" stroke-linejoin="round"/>
      <text x="235" y="140" text-anchor="middle" font-size="18" font-weight="800" fill="#334155" letter-spacing="1">4 : 1 MUX</text>

      
      
      <line id="wire-I0" class="wire" x1="85" y1="60" x2="160" y2="60"/>
      
      <line id="wire-I1" class="wire" x1="85" y1="105" x2="160" y2="105"/>
      
      <line id="wire-I2" class="wire" x1="85" y1="155" x2="160" y2="155"/>
      
      <line id="wire-I3" class="wire" x1="85" y1="200" x2="160" y2="200"/>

      
      <text x="175" y="65" font-size="13" font-weight="700" fill="#64748b">I₀</text>
      <text x="175" y="110" font-size="13" font-weight="700" fill="#64748b">I₁</text>
      <text x="175" y="160" font-size="13" font-weight="700" fill="#64748b">I₂</text>
      <text x="175" y="205" font-size="13" font-weight="700" fill="#64748b">I₃</text>

      
      <text x="298" y="140" font-size="14" font-weight="700" fill="#64748b" text-anchor="end">Y</text>

      
      
      <g class="input-btn" onclick="toggleInput(0)">
        <rect x="25" y="44" width="60" height="32" rx="8" id="box-I0" fill="#e2e8f0" stroke="#cbd5e1" stroke-width="1.5"/>
        <text x="55" y="65" text-anchor="middle" font-size="13" font-weight="700" id="txt-I0" fill="#475569">I₀ = 0</text>
      </g>
      
      <g class="input-btn" onclick="toggleInput(1)">
        <rect x="25" y="89" width="60" height="32" rx="8" id="box-I1" fill="#e2e8f0" stroke="#cbd5e1" stroke-width="1.5"/>
        <text x="55" y="110" text-anchor="middle" font-size="13" font-weight="700" id="txt-I1" fill="#475569">I₁ = 1</text>
      </g>
      
      <g class="input-btn" onclick="toggleInput(2)">
        <rect x="25" y="139" width="60" height="32" rx="8" id="box-I2" fill="#e2e8f0" stroke="#cbd5e1" stroke-width="1.5"/>
        <text x="55" y="160" text-anchor="middle" font-size="13" font-weight="700" id="txt-I2" fill="#475569">I₂ = 0</text>
      </g>
      
      <g class="input-btn" onclick="toggleInput(3)">
        <rect x="25" y="184" width="60" height="32" rx="8" id="box-I3" fill="#e2e8f0" stroke="#cbd5e1" stroke-width="1.5"/>
        <text x="55" y="205" text-anchor="middle" font-size="13" font-weight="700" id="txt-I3" fill="#475569">I₃ = 1</text>
      </g>

      
      <path id="internalPath" d="M 160 60 L 310 135" fill="none" stroke="#22b7ff" stroke-width="3" stroke-linecap="round" opacity="0.9"/>

      
      <line id="wire-Y" class="wire" x1="310" y1="135" x2="385" y2="135"/>
      <circle id="outNode" cx="410" cy="135" r="18" fill="#e2e8f0" stroke="#cbd5e1" stroke-width="2"/>
      <text id="outText" x="410" y="141" text-anchor="middle" font-size="15" font-weight="800" fill="#64748b">0</text>
      <text x="410" y="170" text-anchor="middle" font-size="12" font-weight="700" fill="#64748b">Output Y</text>

      
      <line x1="210" y1="10" x2="210" y2="24" stroke="#94a3b8" stroke-width="2.5"/>
      <circle cx="210" cy="27" r="3" fill="#ffffff" stroke="#94a3b8" stroke-width="2"/>
      <text x="210" y="6" text-anchor="middle" font-size="11" font-weight="700" fill="#64748b">E&#773;</text>

      
      <line x1="240" y1="218" x2="240" y2="255" stroke="#94a3b8" stroke-width="2.5"/>
      <line x1="265" y1="211" x2="265" y2="255" stroke="#94a3b8" stroke-width="2.5"/>
      <text x="240" y="267" text-anchor="middle" font-size="11" font-weight="700" fill="#64748b">S&#8321;</text>
      <text x="265" y="267" text-anchor="middle" font-size="11" font-weight="700" fill="#64748b">S&#8320;</text>
    </svg>
  </div>
</div>

<script>
  const state = {
    enable: 0, // 0 = Active, 1 = Disabled (Active-low)
    s1: 0,
    s0: 0,
    inputs: [0, 1, 0, 1]
  };

  const channelYCoords = [60, 105, 155, 200];

  function toggleEnable() {
    state.enable = state.enable === 0 ? 1 : 0;
    updateUI();
  }

  function toggleS(bit) {
    if (bit === 1) state.s1 = state.s1 === 0 ? 1 : 0;
    if (bit === 0) state.s0 = state.s0 === 0 ? 1 : 0;
    updateUI();
  }

  function toggleInput(idx) {
    state.inputs[idx] = state.inputs[idx] === 0 ? 1 : 0;
    updateUI();
  }

  function updateUI() {
    // Update Enable Button
    const btnE = document.getElementById('btnE');
    btnE.textContent = state.enable;
    if (state.enable === 0) {
      btnE.className = 'btn-toggle active';
    } else {
      btnE.className = 'btn-toggle disabled-en';
    }

    // Update Select Buttons
    const btnS1 = document.getElementById('btnS1');
    const btnS0 = document.getElementById('btnS0');
    btnS1.textContent = state.s1;
    btnS0.textContent = state.s0;
    btnS1.className = state.s1 ? 'btn-toggle active' : 'btn-toggle';
    btnS0.className = state.s0 ? 'btn-toggle active' : 'btn-toggle';

    // Calculate Selected Channel
    const selectedChannel = (state.s1 << 1) | state.s0;
    document.getElementById('channelLabel').textContent = `I${selectedChannel}`;

    // Update Input Badges & Input Wires
    for (let i = 0; i < 4; i++) {
      const val = state.inputs[i];
      const isHigh = val === 1;
      const isSelected = (i === selectedChannel);

      const box = document.getElementById(`box-I${i}`);
      const txt = document.getElementById(`txt-I${i}`);
      const wire = document.getElementById(`wire-I${i}`);

      txt.textContent = `I${i} = ${val}`;

      if (isHigh) {
        box.setAttribute('fill', '#e0f2fe');
        box.setAttribute('stroke', '#38bdf8');
        txt.setAttribute('fill', '#0284c7');
        wire.setAttribute('stroke', isSelected ? '#0284c7' : '#38bdf8');
      } else {
        box.setAttribute('fill', '#f1f5f9');
        box.setAttribute('stroke', '#cbd5e1');
        txt.setAttribute('fill', '#64748b');
        wire.setAttribute('stroke', isSelected ? '#334155' : '#cbd5e1');
      }
      wire.setAttribute('stroke-width', isSelected ? '4.5' : '2.5');
    }

    // Determine Output Y
    const isChipActive = (state.enable === 0);
    const outputVal = isChipActive ? state.inputs[selectedChannel] : 0;

    // Internal path connection
    const path = document.getElementById('internalPath');
    const targetY = channelYCoords[selectedChannel];
    path.setAttribute('d', `M 160 ${targetY} L 310 135`);

    if (!isChipActive) {
      path.setAttribute('stroke', '#cbd5e1');
      path.setAttribute('stroke-dasharray', '4 4');
    } else {
      path.setAttribute('stroke', outputVal ? '#22b7ff' : '#64748b');
      path.removeAttribute('stroke-dasharray');
    }

    // Output Wire and Node
    const outWire = document.getElementById('wire-Y');
    const outNode = document.getElementById('outNode');
    const outText = document.getElementById('outText');

    outText.textContent = outputVal;

    if (!isChipActive) {
      outWire.setAttribute('stroke', '#cbd5e1');
      outNode.setAttribute('fill', '#f1f5f9');
      outNode.setAttribute('stroke', '#cbd5e1');
      outText.setAttribute('fill', '#94a3b8');
      document.getElementById('statusPill').innerHTML = `<span style="color:#ef4444">Disabled (E&#773;=1)</span>`;
    } else {
      document.getElementById('statusPill').innerHTML = `Channel: <strong style="color:#0284c7">I${selectedChannel}</strong>`;
      if (outputVal === 1) {
        outWire.setAttribute('stroke', '#22b7ff');
        outNode.setAttribute('fill', '#22b7ff');
        outNode.setAttribute('stroke', '#0ea5e9');
        outText.setAttribute('fill', '#ffffff');
      } else {
        outWire.setAttribute('stroke', '#64748b');
        outNode.setAttribute('fill', '#e2e8f0');
        outNode.setAttribute('stroke', '#94a3b8');
        outText.setAttribute('fill', '#475569');
      }
    }
  }

  // Initial render
  updateUI();
</script>

</body>
</html>

A common mistake when working with multiplexers is confusing the **select code** with the **data value**. For example, setting $S_1S_0 = 10_2$ selects input channel $I_2$ — it does not force output $Y$ to be binary $1$ unless the signal currently sitting on $I_2$ is high.

Now that you can route arbitrary signals and decode addresses, you have the exact foundation needed to use multiplexers as universal logic engines that can replace entire networks of logic gates.

electronics

Multiplexer Fundamentals: 2-to-1, 4-to-1, and 8-to-1 Multiplexers. Explain data routing, select address lines, enable inputs, and truth tables of 2-to-1, 4-to-1, and 8-to-1 multiplexers.

The Multiplexer (Data Selector) and Multiplexing Tutorial

Digital Combinational Logic: Multiplexers and Data Routing

Multiplexers in Digital Logic: 2-to-1, 4-to-1, 8-to-1 Architecture & Truth Tables

When teaching A2 Level (Year 13) multiplexers under specification ELEC-3.4, start with the physical concept of signal routing using simple mechanical single-pole multi-throw (SPMT) switches before transitioning to AND-OR gate networks. Emphasize the relationship $2^n = \text{inputs}$, link truth tables directly to minterms, and highlight how enable lines allow cascading multiple smaller multiplexers to build larger selector circuits.

Multiplexer Fundamentals: 2-to-1, 4-to-1, and 8-to-1 Multiplexers

The 2-to-1 Multiplexer

Address Line Scaling and the 4-to-1 MUX