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 tiny ladybug walking all the way around the edge of your notebook. How far did the ladybug walk?

The **perimeter** is the total continuous boundary distance enclosing a two-dimensional **polygon**, calculated by summing all outer side lengths: $$P = \sum_{i=1}^{n} s_i$$

Mathematically, the **perimeter** ($P$) is the continuous boundary distance enclosing a two-dimensional polygon, calculated by summing all outer side lengths: $P = \sum_{i=1}^{n} s_i$, where we add each side from $i=1$ up to $n$.

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

    .tabs {
      display: flex;
      gap: 8px;
      justify-content: center;
      width: 100%;
      max-width: 420px;
    }
    .tab-btn {
      flex: 1;
      padding: 6px 10px;
      border: 1px solid #e2e8f0;
      background: #ffffff;
      border-radius: 8px;
      font-size: 13px;
      font-weight: 600;
      color: #64748b;
      cursor: pointer;
      transition: all 0.2s ease;
      text-align: center;
    }
    .tab-btn.active {
      background: #22b7ff;
      color: #ffffff;
      border-color: #22b7ff;
      box-shadow: 0 2px 6px rgba(34, 183, 255, 0.3);
    }

    .stage {
      width: 100%;
      max-width: 380px;
      height: 190px;
      display: flex;
      align-items: center;
      justify-content: center;
      position: relative;
    }
    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
    }
    .poly-fill {
      fill: #f1f5f9;
      stroke: none;
    }
    .poly-side {
      stroke-width: 5;
      stroke-linecap: round;
      cursor: pointer;
      transition: stroke-width 0.2s ease, opacity 0.2s ease;
    }
    .poly-side:hover, .poly-side.active {
      stroke-width: 8;
    }
    .side-label {
      font-size: 13px;
      font-weight: 700;
      fill: #1e2945;
      text-anchor: middle;
      dominant-baseline: middle;
      pointer-events: none;
      paint-order: stroke;
      stroke: #ffffff;
      stroke-width: 4px;
      stroke-linejoin: round;
    }

    /* Unfolded linear tape */
    .unfolded-wrap {
      width: 100%;
      max-width: 380px;
      display: flex;
      flex-direction: column;
      gap: 6px;
    }
    .tape {
      display: flex;
      width: 100%;
      height: 24px;
      background: #e2e8f0;
      border-radius: 6px;
      overflow: hidden;
    }
    .tape-seg {
      height: 100%;
      display: flex;
      align-items: center;
      justify-content: center;
      color: #ffffff;
      font-size: 11px;
      font-weight: 700;
      cursor: pointer;
      transition: filter 0.2s ease, opacity 0.2s ease;
    }
    .tape-seg:hover, .tape-seg.active {
      filter: brightness(1.15);
      box-shadow: inset 0 0 0 2px #ffffff;
    }

    /* Equation row */
    .equation {
      display: flex;
      align-items: center;
      justify-content: center;
      flex-wrap: wrap;
      gap: 4px;
      font-size: 15px;
      font-weight: 700;
      min-height: 32px;
      padding: 4px;
    }
    .eq-part {
      padding: 2px 6px;
      border-radius: 4px;
      color: #ffffff;
      transition: transform 0.2s ease;
    }
    .eq-part.active {
      transform: scale(1.15);
    }
    .eq-op {
      color: #94a3b8;
    }
    .eq-total {
      color: #1e2945;
      background: #ffffff;
      border: 1.5px solid #cbd5e1;
      padding: 2px 8px;
      border-radius: 6px;
    }

    /* Color classes */
    .c0 { background: #3b82f6; stroke: #3b82f6; }
    .c1 { background: #10b981; stroke: #10b981; }
    .c2 { background: #f59e0b; stroke: #f59e0b; }
    .c3 { background: #8b5cf6; stroke: #8b5cf6; }
    .c4 { background: #ec4899; stroke: #ec4899; }
    .c5 { background: #06b6d4; stroke: #06b6d4; }
  </style>
</head>
<body>

  <div class="tabs">
    <button class="tab-btn active" onclick="setShape(0)">Triangle</button>
    <button class="tab-btn" onclick="setShape(1)">Trapezoid</button>
    <button class="tab-btn" onclick="setShape(2)">Hexagon</button>
  </div>

  <div class="stage">
    <svg id="polySvg" viewBox="0 0 340 180"></svg>
  </div>

  <div class="unfolded-wrap">
    <div class="tape" id="tape"></div>
    <div class="equation" id="equation"></div>
  </div>

  <script>
    const shapes = [
      {
        name: 'Triangle',
        pts: [[70, 150], [250, 150], [70, 30]],
        sides: [
          { len: 8, label: '8 cm', color: 'c0', p1: [70, 150], p2: [250, 150], lp: [160, 165] },
          { len: 10, label: '10 cm', color: 'c1', p1: [250, 150], p2: [70, 30], lp: [175, 80] },
          { len: 6, label: '6 cm', color: 'c2', p1: [70, 30], p2: [70, 150], lp: [45, 90] }
        ]
      },
      {
        name: 'Trapezoid',
        pts: [[60, 150], [270, 150], [210, 40], [120, 40]],
        sides: [
          { len: 7, label: '7 cm', color: 'c0', p1: [60, 150], p2: [270, 150], lp: [165, 165] },
          { len: 4, label: '4 cm', color: 'c1', p1: [270, 150], p2: [210, 40], lp: [255, 90] },
          { len: 3, label: '3 cm', color: 'c2', p1: [210, 40], p2: [120, 40], lp: [165, 25] },
          { len: 4, label: '4 cm', color: 'c3', p1: [120, 40], p2: [60, 150], lp: [75, 90] }
        ]
      },
      {
        name: 'Hexagon',
        pts: [[60, 40], [150, 40], [150, 95], [240, 95], [240, 150], [60, 150]],
        sides: [
          { len: 3, label: '3 cm', color: 'c0', p1: [60, 40], p2: [150, 40], lp: [105, 25] },
          { len: 2, label: '2 cm', color: 'c1', p1: [150, 40], p2: [150, 95], lp: [168, 68] },
          { len: 3, label: '3 cm', color: 'c2', p1: [150, 95], p2: [240, 95], lp: [195, 80] },
          { len: 2, label: '2 cm', color: 'c3', p1: [240, 95], p2: [240, 150], lp: [258, 122] },
          { len: 6, label: '6 cm', color: 'c4', p1: [240, 150], p2: [60, 150], lp: [150, 165] },
          { len: 4, label: '4 cm', color: 'c5', p1: [60, 150], p2: [60, 40], lp: [42, 95] }
        ]
      }
    ];

    let currentIdx = 0;
    let activeSide = -1;

    function render() {
      const shp = shapes[currentIdx];
      const totalLen = shp.sides.reduce((sum, s) => sum + s.len, 0);

      // SVG
      const ptsStr = shp.pts.map(p => p.join(',')).join(' ');
      let svgHtml = `<polygon class="poly-fill" points="${ptsStr}" />`;

      shp.sides.forEach((s, i) => {
        const isAct = activeSide === i;
        svgHtml += `
          <line class="poly-side ${s.color} ${isAct ? 'active' : ''}" 
                x1="${s.p1[0]}" y1="${s.p1[1]}" x2="${s.p2[0]}" y2="${s.p2[1]}" 
                onmouseenter="highlight(${i})" onmouseleave="highlight(-1)" onclick="highlight(${i})" />
          <text class="side-label" x="${s.lp[0]}" y="${s.lp[1]}">${s.label}</text>
        `;
      });
      document.getElementById('polySvg').innerHTML = svgHtml;

      // Tape Bar
      let tapeHtml = '';
      shp.sides.forEach((s, i) => {
        const pct = (s.len / totalLen) * 100;
        const isAct = activeSide === i;
        tapeHtml += `
          <div class="tape-seg ${s.color} ${isAct ? 'active' : ''}" 
               style="width: ${pct}%" 
               onmouseenter="highlight(${i})" onmouseleave="highlight(-1)" onclick="highlight(${i})">
            ${s.len}
          </div>
        `;
      });
      document.getElementById('tape').innerHTML = tapeHtml;

      // Equation
      let eqHtml = '<span style="color:#64748b; margin-right:4px;">P = </span>';
      shp.sides.forEach((s, i) => {
        const isAct = activeSide === i;
        eqHtml += `<span class="eq-part ${s.color} ${isAct ? 'active' : ''}">${s.len}</span>`;
        if (i < shp.sides.length - 1) eqHtml += '<span class="eq-op">+</span>';
      });
      eqHtml += `<span class="eq-op">=</span><span class="eq-total">${totalLen} cm</span>`;
      document.getElementById('equation').innerHTML = eqHtml;
    }

    function highlight(idx) {
      activeSide = idx;
      render();
    }

    function setShape(idx) {
      currentIdx = idx;
      activeSide = -1;
      document.querySelectorAll('.tab-btn').forEach((b, i) => {
        b.classList.toggle('active', i === idx);
      });
      render();
    }

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

How do we find the perimeter when all the sides are the exact same length?

When every side of a shape has the same length, we call it a **regular polygon**.

To find its perimeter, just add that same side length for every side the shape has.

<!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">
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.8/katex.min.css">
  <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%;
    }

    /* Tabs */
    .tabs {
      display: flex;
      gap: 8px;
      margin-bottom: 8px;
      flex-wrap: wrap;
      justify-content: center;
    }

    .tab-btn {
      background: #ffffff;
      border: 2px solid #e2e8f0;
      border-radius: 20px;
      padding: 6px 14px;
      font-size: 14px;
      font-weight: 600;
      color: #64748b;
      cursor: pointer;
      transition: all 0.2s ease;
    }

    .tab-btn.active {
      background: #22b7ff;
      border-color: #22b7ff;
      color: #ffffff;
    }

    /* Canvas Stage */
    .stage {
      background: #ffffff;
      border-radius: 12px;
      width: 100%;
      max-width: 480px;
      height: 230px;
      display: flex;
      align-items: center;
      justify-content: center;
      position: relative;
      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.04);
    }

    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
    }

    .polygon-fill {
      fill: rgba(34, 183, 255, 0.08);
      stroke: #cbd5e1;
      stroke-width: 3;
      stroke-linejoin: round;
    }

    .side-seg {
      stroke-width: 6;
      stroke-linecap: round;
      transition: stroke 0.3s ease, stroke-width 0.3s ease;
      cursor: pointer;
    }

    .side-seg.active {
      stroke-width: 7;
    }

    .side-label {
      font-size: 14px;
      font-weight: 700;
      fill: #1e2945;
      text-anchor: middle;
      dominant-baseline: middle;
      user-select: none;
      transition: fill 0.3s ease, transform 0.3s ease;
    }

    /* Formula & Result Panel */
    .calc-panel {
      width: 100%;
      max-width: 480px;
      background: #ffffff;
      border-radius: 12px;
      padding: 10px 14px;
      margin-top: 8px;
      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.04);
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 6px;
    }

    .equation {
      display: flex;
      align-items: center;
      justify-content: center;
      flex-wrap: wrap;
      gap: 6px;
      font-size: 16px;
      font-weight: 600;
      min-height: 32px;
    }

    .term {
      padding: 3px 8px;
      border-radius: 6px;
      border: 1.5px solid transparent;
      transition: all 0.3s ease;
      font-size: 15px;
    }

    .term.active {
      background: rgba(34, 183, 255, 0.15);
      border-color: #22b7ff;
      color: #0284c7;
      font-weight: 700;
    }

    .total-badge {
      background: #22b7ff;
      color: #ffffff;
      padding: 4px 12px;
      border-radius: 8px;
      font-weight: 700;
      font-size: 16px;
    }

    /* Controls */
    .controls {
      display: flex;
      gap: 10px;
      align-items: center;
      margin-top: 4px;
    }

    .ctrl-btn {
      background: #f1f5f9;
      border: 1px solid #cbd5e1;
      border-radius: 6px;
      padding: 4px 12px;
      font-size: 13px;
      font-weight: 600;
      color: #334155;
      cursor: pointer;
      transition: all 0.2s ease;
    }

    .ctrl-btn:hover {
      background: #e2e8f0;
    }
  </style>
</head>
<body>

  
  <div class="tabs">
    <button class="tab-btn active" data-shape="0">Triangle</button>
    <button class="tab-btn" data-shape="1">Square</button>
    <button class="tab-btn" data-shape="2">Pentagon</button>
    <button class="tab-btn" data-shape="3">Hexagon</button>
  </div>

  
  <div class="stage">
    <svg id="svgStage" viewBox="0 0 320 220"></svg>
  </div>

  
  <div class="calc-panel">
    <div class="equation" id="equationContainer"></div>
    <div class="controls">
      <button class="ctrl-btn" id="prevBtn">◀ Step</button>
      <button class="ctrl-btn" id="playBtn">⏸ Pause</button>
      <button class="ctrl-btn" id="nextBtn">Step ▶</button>
    </div>
  </div>

  <script>
    const shapes = [
      { name: "Triangle", sides: 3, len: 4, unit: "cm", radius: 70, offsetAngle: -90, yOffset: 15 },
      { name: "Square", sides: 4, len: 5, unit: "cm", radius: 68, offsetAngle: -45, yOffset: 0 },
      { name: "Pentagon", sides: 5, len: 3, unit: "cm", radius: 68, offsetAngle: -90, yOffset: 6 },
      { name: "Hexagon", sides: 6, len: 2, unit: "cm", radius: 68, offsetAngle: 0, yOffset: 0 }
    ];

    const COLORS = [
      "#0284c7", // blue
      "#16a34a", // green
      "#ea580c", // orange
      "#9333ea", // purple
      "#db2777", // pink
      "#ca8a04"  // yellow-gold
    ];

    let currentShapeIdx = 0;
    let activeSide = 0;
    let isPlaying = true;
    let timer = null;

    const svg = document.getElementById("svgStage");
    const eqContainer = document.getElementById("equationContainer");
    const playBtn = document.getElementById("playBtn");
    const prevBtn = document.getElementById("prevBtn");
    const nextBtn = document.getElementById("nextBtn");
    const tabBtns = document.querySelectorAll(".tab-btn");

    function getPoints(shape) {
      const cx = 160;
      const cy = 110 + shape.yOffset;
      const pts = [];
      for (let i = 0; i < shape.sides; i++) {
        const angle = (shape.offsetAngle + (i * 360) / shape.sides) * (Math.PI / 180);
        pts.push({
          x: cx + shape.radius * Math.cos(angle),
          y: cy + shape.radius * Math.sin(angle)
        });
      }
      return pts;
    }

    function renderShape() {
      const s = shapes[currentShapeIdx];
      const pts = getPoints(s);
      svg.innerHTML = "";

      // Background polygon
      const polyPtsStr = pts.map(p => `${p.x.toFixed(1)},${p.y.toFixed(1)}`).join(" ");
      const poly = document.createElementNS("http://www.w3.org/2000/svg", "polygon");
      poly.setAttribute("points", polyPtsStr);
      poly.setAttribute("class", "polygon-fill");
      svg.appendChild(poly);

      // Sides & Labels
      for (let i = 0; i < s.sides; i++) {
        const p1 = pts[i];
        const p2 = pts[(i + 1) % s.sides];
        const color = COLORS[i % COLORS.length];

        // Side line segment
        const line = document.createElementNS("http://www.w3.org/2000/svg", "line");
        line.setAttribute("x1", p1.x);
        line.setAttribute("y1", p1.y);
        line.setAttribute("x2", p2.x);
        line.setAttribute("y2", p2.y);
        line.setAttribute("class", `side-seg side-${i} ${i === activeSide ? "active" : ""}`);
        line.setAttribute("stroke", i === activeSide ? color : "#cbd5e1");
        line.onclick = () => { activeSide = i; updateState(); };
        svg.appendChild(line);

        // Side label placed outward along normal
        const midX = (p1.x + p2.x) / 2;
        const midY = (p1.y + p2.y) / 2;
        const dx = p2.x - p1.x;
        const dy = p2.y - p1.y;
        const len = Math.hypot(dx, dy);
        const nx = -(dy / len);
        const ny = (dx / len);
        const labelDist = 18;

        const text = document.createElementNS("http://www.w3.org/2000/svg", "text");
        text.setAttribute("x", midX + nx * labelDist);
        text.setAttribute("y", midY + ny * labelDist);
        text.setAttribute("class", `side-label label-${i}`);
        text.textContent = `${s.len} ${s.unit}`;
        if (i === activeSide) {
          text.setAttribute("fill", color);
          text.setAttribute("font-size", "16px");
        }
        svg.appendChild(text);
      }

      renderEquation();
    }

    function renderEquation() {
      const s = shapes[currentShapeIdx];
      eqContainer.innerHTML = "";

      for (let i = 0; i < s.sides; i++) {
        const term = document.createElement("span");
        term.className = `term ${i === activeSide ? "active" : ""}`;
        term.style.color = i === activeSide ? COLORS[i % COLORS.length] : "#64748b";
        term.textContent = `${s.len} ${s.unit}`;
        eqContainer.appendChild(term);

        if (i < s.sides - 1) {
          const plus = document.createElement("span");
          plus.textContent = "+";
          plus.style.color = "#94a3b8";
          eqContainer.appendChild(plus);
        }
      }

      const eq = document.createElement("span");
      eq.textContent = "=";
      eq.style.color = "#94a3b8";
      eqContainer.appendChild(eq);

      const total = document.createElement("span");
      total.className = "total-badge";
      total.textContent = `${s.sides * s.len} ${s.unit}`;
      eqContainer.appendChild(total);
    }

    function updateState() {
      const s = shapes[currentShapeIdx];
      // Update SVG lines
      for (let i = 0; i < s.sides; i++) {
        const line = svg.querySelector(`.side-${i}`);
        const label = svg.querySelector(`.label-${i}`);
        const color = COLORS[i % COLORS.length];

        if (line) {
          line.setAttribute("stroke", i === activeSide ? color : "#cbd5e1");
          line.classList.toggle("active", i === activeSide);
        }
        if (label) {
          label.setAttribute("fill", i === activeSide ? color : "#1e2945");
          label.setAttribute("font-size", i === activeSide ? "16px" : "14px");
        }
      }

      // Update equation terms
      const terms = eqContainer.querySelectorAll(".term");
      terms.forEach((t, i) => {
        t.classList.toggle("active", i === activeSide);
        t.style.color = i === activeSide ? COLORS[i % COLORS.length] : "#64748b";
      });
    }

    function nextStep() {
      const s = shapes[currentShapeIdx];
      activeSide = (activeSide + 1) % s.sides;
      updateState();
    }

    function prevStep() {
      const s = shapes[currentShapeIdx];
      activeSide = (activeSide - 1 + s.sides) % s.sides;
      updateState();
    }

    function startTimer() {
      clearInterval(timer);
      timer = setInterval(nextStep, 3000);
    }

    function stopTimer() {
      clearInterval(timer);
    }

    // Event listeners
    tabBtns.forEach(btn => {
      btn.addEventListener("click", () => {
        tabBtns.forEach(b => b.classList.remove("active"));
        btn.classList.add("active");
        currentShapeIdx = parseInt(btn.dataset.shape, 10);
        activeSide = 0;
        renderShape();
      });
    });

    playBtn.addEventListener("click", () => {
      isPlaying = !isPlaying;
      playBtn.textContent = isPlaying ? "⏸ Pause" : "▶ Play";
      if (isPlaying) startTimer();
      else stopTimer();
    });

    nextBtn.addEventListener("click", () => {
      nextStep();
      if (isPlaying) startTimer();
    });

    prevBtn.addEventListener("click", () => {
      prevStep();
      if (isPlaying) startTimer();
    });

    // Init
    renderShape();
    startTimer();
  </script>
</body>
</html>

For the triangle, adding all 3 sides gives $4\text{ cm} + 4\text{ cm} + 4\text{ cm} = 12\text{ cm}$.

What if the sides are not all the same length?

An **irregular polygon** is a shape where the sides have different lengths.

The rule is still the same: start at one corner and add up every side until you get back to where you started.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Calculating Perimeter of a Polygon</title>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }
    body {
      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
      background: transparent;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
      padding: 12px 16px;
      user-select: none;
    }
    .main-stage {
      width: 100%;
      max-width: 440px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 12px;
    }
    .svg-container {
      width: 100%;
      max-width: 360px;
      height: 220px;
      position: relative;
    }
    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
    }
    .poly-base {
      fill: #f0f7ff;
      stroke: #d0d7de;
      stroke-width: 3;
      stroke-linejoin: round;
    }
    .side-path {
      stroke-width: 6;
      stroke-linecap: round;
      fill: none;
      transition: stroke 0.3s ease, stroke-width 0.3s ease, opacity 0.3s ease;
      opacity: 0.25;
    }
    .side-path.active {
      opacity: 1;
      stroke-width: 7;
      filter: drop-shadow(0 2px 4px rgba(34, 183, 255, 0.4));
    }
    .side-path.visited {
      opacity: 0.85;
      stroke-width: 5;
    }
    .s1 { stroke: #0284c7; }
    .s2 { stroke: #0d9488; }
    .s3 { stroke: #d97706; }
    .s4 { stroke: #7c3aed; }

    .side-label {
      font-size: 15px;
      font-weight: 700;
      text-anchor: middle;
      dominant-baseline: central;
      transition: fill 0.3s ease, transform 0.3s ease;
    }
    .l1 { fill: #0284c7; }
    .l2 { fill: #0d9488; }
    .l3 { fill: #d97706; }
    .l4 { fill: #7c3aed; }

    .marker-start {
      fill: #ffffff;
      stroke: #1e2945;
      stroke-width: 2.5;
    }
    .marker-walker {
      fill: #22b7ff;
      stroke: #ffffff;
      stroke-width: 2.5;
      filter: drop-shadow(0 2px 5px rgba(0,0,0,0.25));
      transition: cx 0.5s ease, cy 0.5s ease;
    }
    .start-badge {
      font-size: 11px;
      font-weight: 700;
      fill: #1e2945;
      text-anchor: end;
      dominant-baseline: central;
    }

    .equation-card {
      width: 100%;
      background: #ffffff;
      border-radius: 12px;
      box-shadow: 0 2px 8px rgba(0,0,0,0.06);
      padding: 10px 14px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 6px;
      border: 1px solid #e2e8f0;
    }
    .eq-row {
      display: flex;
      align-items: center;
      gap: 6px;
      font-size: 17px;
      font-weight: 700;
      flex-wrap: wrap;
      justify-content: center;
    }
    .term {
      padding: 2px 8px;
      border-radius: 6px;
      background: #f1f5f9;
      color: #94a3b8;
      transition: all 0.3s ease;
    }
    .term.t1.active, .term.t1.visited { background: #e0f2fe; color: #0284c7; }
    .term.t2.active, .term.t2.visited { background: #ccfbf1; color: #0d9488; }
    .term.t3.active, .term.t3.visited { background: #fef3c7; color: #d97706; }
    .term.t4.active, .term.t4.visited { background: #ede9fe; color: #7c3aed; }
    .term.active {
      transform: scale(1.08);
      box-shadow: 0 0 0 2px currentColor;
    }
    .total-badge {
      padding: 2px 10px;
      border-radius: 6px;
      background: #f8fafc;
      color: #94a3b8;
      transition: all 0.3s ease;
    }
    .total-badge.complete {
      background: #22b7ff;
      color: #ffffff;
      transform: scale(1.05);
    }
    .status-text {
      font-size: 13px;
      color: #64748b;
      font-weight: 600;
    }

    .controls-row {
      width: 100%;
      max-width: 440px;
      display: flex;
      justify-content: center;
      align-items: center;
      gap: 8px;
      margin-top: 4px;
    }
    .step-btn {
      padding: 6px 12px;
      font-size: 13px;
      font-weight: 600;
      background: #ffffff;
      border: 1px solid #cbd5e1;
      border-radius: 8px;
      color: #475569;
      cursor: pointer;
      display: inline-flex;
      align-items: center;
      justify-content: center;
      min-width: 38px;
      transition: background 0.2s, color 0.2s, border-color 0.2s;
    }
    .step-btn.active {
      background: #22b7ff;
      color: #ffffff;
      border-color: #22b7ff;
    }
    .play-btn {
      padding: 6px 14px;
      font-size: 13px;
      font-weight: 600;
      background: #1e2945;
      color: #ffffff;
      border: 1px solid #1e2945;
      border-radius: 8px;
      cursor: pointer;
      display: inline-flex;
      align-items: center;
      gap: 4px;
    }
  </style>
</head>
<body>

  <div class="main-stage">
    <div class="svg-container">
      <svg viewBox="0 0 340 210">
        
        <polygon points="100,45 220,45 300,185 80,185" class="poly-base" />

        
        <line x1="100" y1="45" x2="220" y2="45" id="edge1" class="side-path s1" />
        
        <line x1="220" y1="45" x2="300" y2="185" id="edge2" class="side-path s2" />
        
        <line x1="300" y1="185" x2="80" y2="185" id="edge3" class="side-path s3" />
        
        <line x1="80" y1="185" x2="100" y2="45" id="edge4" class="side-path s4" />

        
        <text x="160" y="30" class="side-label l1">2 in</text>
        <text x="278" y="110" class="side-label l2">5 in</text>
        <text x="190" y="202" class="side-label l3">4 in</text>
        <text x="70" y="115" class="side-label l4">3 in</text>

        
        <text x="88" y="45" class="start-badge">Start</text>
        <circle cx="100" cy="45" r="5" class="marker-start" />

        
        <circle id="walker" cx="100" cy="45" r="8" class="marker-walker" />
      </svg>
    </div>

    
    <div class="equation-card">
      <div class="eq-row">
        <span id="t1" class="term t1">2 in</span>
        <span>+</span>
        <span id="t2" class="term t2">5 in</span>
        <span>+</span>
        <span id="t3" class="term t3">4 in</span>
        <span>+</span>
        <span id="t4" class="term t4">3 in</span>
        <span>=</span>
        <span id="tot" class="total-badge">14 in</span>
      </div>
      <div id="subtext" class="status-text">Start at top-left corner</div>
    </div>
  </div>

  
  <div class="controls-row">
    <button id="playBtn" class="play-btn">⏸ Pause</button>
    <button class="step-btn" data-step="0">Start</button>
    <button class="step-btn" data-step="1">1</button>
    <button class="step-btn" data-step="2">2</button>
    <button class="step-btn" data-step="3">3</button>
    <button class="step-btn" data-step="4">4</button>
  </div>

  <script>
    const points = [
      { x: 100, y: 45, text: "Start at top-left corner" },
      { x: 220, y: 45, text: "Side 1: + 2 in (Sum = 2 in)" },
      { x: 300, y: 185, text: "Side 2: + 5 in (Sum = 7 in)" },
      { x: 80, y: 185, text: "Side 3: + 4 in (Sum = 11 in)" },
      { x: 100, y: 45, text: "Side 4: + 3 in → Perimeter = 14 in" }
    ];

    let currentStep = 0;
    let isPlaying = true;
    let timer = null;

    const walker = document.getElementById('walker');
    const edges = [
      document.getElementById('edge1'),
      document.getElementById('edge2'),
      document.getElementById('edge3'),
      document.getElementById('edge4')
    ];
    const terms = [
      document.getElementById('t1'),
      document.getElementById('t2'),
      document.getElementById('t3'),
      document.getElementById('t4')
    ];
    const totBadge = document.getElementById('tot');
    const subtext = document.getElementById('subtext');
    const stepBtns = document.querySelectorAll('.step-btn');
    const playBtn = document.getElementById('playBtn');

    function renderStep(step) {
      currentStep = step;

      // Update walker dot position
      walker.setAttribute('cx', points[step].x);
      walker.setAttribute('cy', points[step].y);

      // Update edge states
      edges.forEach((edge, idx) => {
        edge.classList.remove('active', 'visited');
        if (step > 0 && idx === step - 1) {
          edge.classList.add('active');
        } else if (step > 0 && idx < step - 1) {
          edge.classList.add('visited');
        }
      });

      // Update equation terms
      terms.forEach((term, idx) => {
        term.classList.remove('active', 'visited');
        if (step > 0 && idx === step - 1) {
          term.classList.add('active');
        } else if (step > 0 && idx < step - 1) {
          term.classList.add('visited');
        }
      });

      // Total badge
      if (step === 4) {
        totBadge.classList.add('complete');
      } else {
        totBadge.classList.remove('complete');
      }

      // Step text
      subtext.textContent = points[step].text;

      // Update step buttons
      stepBtns.forEach((btn, idx) => {
        btn.classList.toggle('active', idx === step);
      });
    }

    function advance() {
      const next = (currentStep + 1) % 5;
      renderStep(next);
    }

    function startTimer() {
      if (timer) clearInterval(timer);
      timer = setInterval(advance, 3000);
    }

    function stopTimer() {
      if (timer) {
        clearInterval(timer);
        timer = null;
      }
    }

    playBtn.addEventListener('click', () => {
      isPlaying = !isPlaying;
      playBtn.textContent = isPlaying ? '⏸ Pause' : '▶ Play';
      if (isPlaying) {
        advance();
        startTimer();
      } else {
        stopTimer();
      }
    });

    stepBtns.forEach((btn, idx) => {
      btn.addEventListener('click', () => {
        renderStep(idx);
        if (isPlaying) {
          startTimer();
        }
      });
    });

    // Initialize
    renderStep(0);
    startTimer();
  </script>
</body>
</html>

We add the sides in order: $2\text{ in} + 5\text{ in} + 4\text{ in} + 3\text{ in} = 14\text{ inches}$.

What is the most important rule when we write down our answer?

A **standard unit** is a set measurement we use to measure length, like inches (in) or centimeters (cm).

Every side must use the exact same unit before you add them together, and your final answer must always include that unit.

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

  .shape-tabs {
    display: flex;
    gap: 8px;
    width: 100%;
    max-width: 440px;
    justify-content: center;
  }
  .tab-btn {
    flex: 1;
    padding: 6px 10px;
    font-size: 13px;
    font-weight: 600;
    border: 1px solid #e2e8f0;
    background: #ffffff;
    color: #64748b;
    border-radius: 8px;
    cursor: pointer;
    text-align: center;
    transition: all 0.2s ease;
  }
  .tab-btn.active {
    background: #22b7ff;
    color: #ffffff;
    border-color: #22b7ff;
    box-shadow: 0 2px 6px rgba(34, 183, 255, 0.3);
  }

  .canvas-card {
    background: #ffffff;
    border: 1px solid #e2e8f0;
    border-radius: 12px;
    width: 100%;
    max-width: 440px;
    height: 220px;
    position: relative;
    display: flex;
    align-items: center;
    justify-content: center;
    overflow: hidden;
  }

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

  .side-line {
    stroke: #cbd5e1;
    stroke-width: 4;
    stroke-linecap: round;
    stroke-linejoin: round;
    transition: stroke 0.3s ease, stroke-width 0.3s ease;
  }
  .side-line.active {
    stroke: #22b7ff;
    stroke-width: 6;
  }
  .side-line.counted {
    stroke: #10b981;
    stroke-width: 4;
  }

  .side-tag {
    position: absolute;
    transform: translate(-50%, -50%);
    font-size: 12px;
    font-weight: 700;
    background: #ffffff;
    padding: 2px 6px;
    border-radius: 6px;
    border: 1px solid #e2e8f0;
    color: #475569;
    display: flex;
    align-items: center;
    gap: 3px;
    transition: all 0.3s ease;
    white-space: nowrap;
  }
  .side-tag.active {
    background: #e0f2fe;
    border-color: #22b7ff;
    color: #0284c7;
    box-shadow: 0 0 0 2px rgba(34, 183, 255, 0.25);
  }
  .side-tag.counted {
    background: #ecfdf5;
    border-color: #10b981;
    color: #059669;
  }
  .check-icon {
    display: inline-block;
    font-size: 11px;
    opacity: 0;
    transform: scale(0.5);
    transition: all 0.2s ease;
  }
  .side-tag.counted .check-icon {
    opacity: 1;
    transform: scale(1);
  }

  .calc-box {
    width: 100%;
    max-width: 440px;
    background: #ffffff;
    border: 1px solid #e2e8f0;
    border-radius: 12px;
    padding: 10px 14px;
    display: flex;
    flex-direction: column;
    gap: 4px;
    min-height: 68px;
    justify-content: center;
  }
  .calc-title {
    font-size: 12px;
    font-weight: 600;
    color: #64748b;
    display: flex;
    justify-content: space-between;
  }
  .calc-formula {
    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
    font-size: 15px;
    font-weight: 700;
    color: #1e2945;
    word-break: break-all;
    line-height: 1.3;
  }
  .term-active {
    color: #0284c7;
    text-decoration: underline;
  }
  .term-counted {
    color: #059669;
  }
  .total-sum {
    color: #0284c7;
    font-size: 16px;
  }

  .controls {
    display: flex;
    align-items: center;
    gap: 8px;
    width: 100%;
    max-width: 440px;
    justify-content: center;
  }
  .btn {
    padding: 7px 14px;
    font-size: 13px;
    font-weight: 600;
    border-radius: 8px;
    border: 1px solid #e2e8f0;
    background: #ffffff;
    color: #1e2945;
    cursor: pointer;
    display: inline-flex;
    align-items: center;
    justify-content: center;
    gap: 4px;
    transition: background 0.15s;
  }
  .btn-primary {
    background: #22b7ff;
    color: #ffffff;
    border-color: #22b7ff;
  }
  .step-dots {
    display: flex;
    gap: 5px;
    align-items: center;
  }
  .dot {
    width: 8px;
    height: 8px;
    border-radius: 50%;
    background: #cbd5e1;
    cursor: pointer;
    transition: all 0.2s ease;
  }
  .dot.active {
    background: #22b7ff;
    transform: scale(1.3);
  }
  .dot.counted {
    background: #10b981;
  }
</style>
</head>
<body>

  <div class="shape-tabs">
    <button class="tab-btn active" data-shape="quad">Rectangle</button>
    <button class="tab-btn" data-shape="lshape">L-Shape</button>
    <button class="tab-btn" data-shape="pent">Pentagon</button>
  </div>

  <div class="canvas-card" id="card">
    <svg id="polySvg" viewBox="0 0 380 200"></svg>
    <div id="labelsContainer"></div>
  </div>

  <div class="calc-box">
    <div class="calc-title">
      <span>Perimeter Calculation</span>
      <span id="stepCounter">Step 1 of 4</span>
    </div>
    <div class="calc-formula" id="formula">P = 6 cm</div>
  </div>

  <div class="controls">
    <button class="btn" id="prevBtn">← Back</button>
    <div class="step-dots" id="dots"></div>
    <button class="btn btn-primary" id="nextBtn">Add Next Side →</button>
  </div>

<script>
const shapes = {
  quad: {
    points: [
      { x: 80, y: 40 },
      { x: 300, y: 40 },
      { x: 300, y: 160 },
      { x: 80, y: 160 }
    ],
    lengths: [8, 4, 8, 4],
    unit: 'cm',
    labelOffsets: [
      { dx: 0, dy: -16 },
      { dx: 26, dy: 0 },
      { dx: 0, dy: 16 },
      { dx: -26, dy: 0 }
    ]
  },
  lshape: {
    points: [
      { x: 80, y: 35 },
      { x: 190, y: 35 },
      { x: 190, y: 100 },
      { x: 300, y: 100 },
      { x: 300, y: 165 },
      { x: 80, y: 165 }
    ],
    lengths: [4, 2, 4, 2, 8, 4],
    unit: 'm',
    labelOffsets: [
      { dx: 0, dy: -14 },
      { dx: 20, dy: 0 },
      { dx: 0, dy: -14 },
      { dx: 20, dy: 0 },
      { dx: 0, dy: 16 },
      { dx: -22, dy: 0 }
    ]
  },
  pent: {
    points: [
      { x: 190, y: 35 },
      { x: 305, y: 90 },
      { x: 260, y: 165 },
      { x: 120, y: 165 },
      { x: 75, y: 90 }
    ],
    lengths: [5, 4, 5, 4, 5],
    unit: 'cm',
    labelOffsets: [
      { dx: 18, dy: -12 },
      { dx: 22, dy: 4 },
      { dx: 0, dy: 16 },
      { dx: -22, dy: 4 },
      { dx: -18, dy: -12 }
    ]
  }
};

let currentShapeKey = 'quad';
let currentStep = 0;
let autoTimer = null;

const svg = document.getElementById('polySvg');
const labelsContainer = document.getElementById('labelsContainer');
const formula = document.getElementById('formula');
const stepCounter = document.getElementById('stepCounter');
const dotsContainer = document.getElementById('dots');
const prevBtn = document.getElementById('prevBtn');
const nextBtn = document.getElementById('nextBtn');

function initShape(shapeKey) {
  currentShapeKey = shapeKey;
  currentStep = 0;
  const s = shapes[shapeKey];
  const n = s.points.length;

  svg.innerHTML = '';
  labelsContainer.innerHTML = '';
  dotsContainer.innerHTML = '';

  for (let i = 0; i < n; i++) {
    const p1 = s.points[i];
    const p2 = s.points[(i + 1) % n];

    const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
    line.setAttribute('x1', p1.x);
    line.setAttribute('y1', p1.y);
    line.setAttribute('x2', p2.x);
    line.setAttribute('y2', p2.y);
    line.id = `line-${i}`;
    line.classList.add('side-line');
    svg.appendChild(line);

    const midX = (p1.x + p2.x) / 2 + (s.labelOffsets[i]?.dx || 0);
    const midY = (p1.y + p2.y) / 2 + (s.labelOffsets[i]?.dy || 0);

    const tag = document.createElement('div');
    tag.id = `tag-${i}`;
    tag.className = 'side-tag';
    tag.style.left = (midX / 380 * 100) + '%';
    tag.style.top = (midY / 200 * 100) + '%';
    tag.innerHTML = `<span class="check-icon">✓</span><span>${s.lengths[i]} ${s.unit}</span>`;
    labelsContainer.appendChild(tag);

    const dot = document.createElement('div');
    dot.className = 'dot';
    dot.dataset.step = i;
    dot.addEventListener('click', () => { setStep(i); resetAutoPlay(); });
    dotsContainer.appendChild(dot);
  }

  const finalDot = document.createElement('div');
  finalDot.className = 'dot';
  finalDot.dataset.step = n;
  finalDot.addEventListener('click', () => { setStep(n); resetAutoPlay(); });
  dotsContainer.appendChild(finalDot);

  updateUI();
}

function updateUI() {
  const s = shapes[currentShapeKey];
  const n = s.points.length;
  const totalSteps = n + 1;

  for (let i = 0; i < n; i++) {
    const line = document.getElementById(`line-${i}`);
    const tag = document.getElementById(`tag-${i}`);
    line.className = 'side-line';
    tag.className = 'side-tag';

    if (currentStep === totalSteps - 1) {
      line.classList.add('counted');
      tag.classList.add('counted');
    } else if (i < currentStep) {
      line.classList.add('counted');
      tag.classList.add('counted');
    } else if (i === currentStep) {
      line.classList.add('active');
      tag.classList.add('active');
    }
  }

  const dots = dotsContainer.querySelectorAll('.dot');
  dots.forEach((d, idx) => {
    d.className = 'dot';
    if (idx === currentStep) d.classList.add('active');
    else if (idx < currentStep) d.classList.add('counted');
  });

  if (currentStep === totalSteps - 1) {
    const sum = s.lengths.reduce((a, b) => a + b, 0);
    const sumStr = s.lengths.join(' + ');
    formula.innerHTML = `P = ${sumStr} = <span class="total-sum">${sum} ${s.unit}</span>`;
    stepCounter.textContent = `Total Perimeter`;
    nextBtn.textContent = 'Restart ↺';
  } else {
    const addedTerms = s.lengths.slice(0, currentStep).map(v => `<span class="term-counted">${v}</span>`);
    const activeTerm = `<span class="term-active">${s.lengths[currentStep]}</span>`;
    const terms = [...addedTerms, activeTerm].join(' + ');
    formula.innerHTML = `P = ${terms} ${s.unit}`;
    stepCounter.textContent = `Side ${currentStep + 1} of ${n}`;
    nextBtn.textContent = 'Add Next Side →';
  }

  prevBtn.disabled = currentStep === 0;
  prevBtn.style.opacity = currentStep === 0 ? '0.4' : '1';
}

function setStep(step) {
  const n = shapes[currentShapeKey].points.length;
  currentStep = Math.max(0, Math.min(step, n));
  updateUI();
}

function nextStep() {
  const n = shapes[currentShapeKey].points.length;
  if (currentStep >= n) {
    currentStep = 0;
  } else {
    currentStep++;
  }
  updateUI();
}

function prevStep() {
  if (currentStep > 0) {
    currentStep--;
    updateUI();
  }
}

function startAutoPlay() {
  clearInterval(autoTimer);
  autoTimer = setInterval(() => {
    nextStep();
  }, 3200);
}

function resetAutoPlay() {
  clearInterval(autoTimer);
  startAutoPlay();
}

document.querySelectorAll('.tab-btn').forEach(tab => {
  tab.addEventListener('click', (e) => {
    document.querySelectorAll('.tab-btn').forEach(t => t.classList.remove('active'));
    e.target.classList.add('active');
    initShape(e.target.dataset.shape);
    resetAutoPlay();
  });
});

nextBtn.addEventListener('click', () => { nextStep(); resetAutoPlay(); });
prevBtn.addEventListener('click', () => { prevStep(); resetAutoPlay(); });

initShape('quad');
startAutoPlay();
</script>
</body>
</html>

A common mistake is accidentally skipping a side when adding. A great trick is to place a tiny checkmark next to each side as you add it so none get left out!

math

Calculating Perimeter of Polygons Using Standard Units. Calculate perimeters of regular and irregular polygons ensuring uniform unit usage.

Perimeter of Polygons and Missing Side Lengths

Perimeter of Regular and Irregular Polygons

How to Calculate the Perimeter of 2D Shapes

To achieve mastery across diverse learning frameworks (including Curriculum for Excellence benchmarks), instruction should begin with concrete boundary tracing (using string or rulers) before moving to abstract algebraic addition. Emphasize standard unit checks as the obligatory 'Step Zero' in every geometry calculation to prevent mixed-unit addition errors. Differentiate regular polygons via multiplicative thinking ($P = n \cdot s$) while reinforcing rigorous boundary-tracking strategies for irregular polygons.

Calculating Perimeter of Polygons Using Standard Units

Shapes with Equal Sides

Shapes with Different Sides