Generators-of-Math-Exercises

Math Generators

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Calculus Worksheet Generator</title>
  <meta name="description" content="Free calculus worksheet generator for integrals, derivatives, limits, series, and exam-style mixed practice." />

* { box-sizing: border-box; }

body {
      margin: 0;
      font-family: Inter, Arial, sans-serif;
      color: var(--text);
      background:
        radial-gradient(circle at top left, rgba(124, 156, 255, 0.18), transparent 28%),
        radial-gradient(circle at top right, rgba(156, 124, 255, 0.14), transparent 30%),
        linear-gradient(180deg, var(--bg-1) 0%, var(--bg-2) 100%);
      min-height: 100vh;
    }

.wrap {
      max-width: 1240px;
      margin: 0 auto;
      padding: 28px;
    }

.hero {
      display: grid;
      grid-template-columns: 88px 1fr;
      gap: 18px;
      align-items: center;
      margin-bottom: 24px;
    }

.hero-badge {
      width: 88px;
      height: 88px;
      border-radius: 26px;
      display: grid;
      place-items: center;
      font-size: 40px;
      font-weight: 800;
      background: linear-gradient(135deg, var(--accent), var(--accent-2));
      box-shadow: 0 18px 44px rgba(124, 156, 255, 0.28);
    }

.hero h1 {
      margin: 0 0 10px;
      font-size: clamp(2rem, 4.5vw, 3.4rem);
      line-height: 1.02;
      letter-spacing: -0.03em;
    }

.hero p {
      margin: 0;
      color: var(--muted);
      line-height: 1.7;
      max-width: 920px;
      font-size: 1.03rem;
    }

.topic-nav {
      display: flex;
      gap: 10px;
      flex-wrap: wrap;
      margin: 20px 0 28px;
    }

.topic-nav button {
      width: auto;
      padding: 11px 16px;
      border-radius: 999px;
      border: 1px solid var(--border);
      background: rgba(255, 255, 255, 0.04);
      color: var(--muted);
      cursor: pointer;
      font-weight: 700;
      transition: 0.2s ease;
    }

.topic-nav button:hover {
      transform: translateY(-1px);
      color: var(--text);
    }

.topic-nav button.active {
      background: linear-gradient(135deg, var(--accent), var(--accent-2));
      color: white;
      border: none;
      box-shadow: 0 14px 30px rgba(124, 156, 255, 0.22);
    }

.grid {
      display: grid;
      grid-template-columns: 360px 1fr;
      gap: 24px;
      align-items: start;
    }

.card {
      background: var(--panel);
      border: 1px solid var(--border);
      border-radius: 28px;
      padding: 22px;
      box-shadow: var(--shadow);
      backdrop-filter: blur(14px);
    }

.settings-card {
      position: sticky;
      top: 18px;
    }

.stack > * + * {
      margin-top: 16px;
    }

.card h2 {
      margin: 0 0 6px;
      font-size: 1.2rem;
    }

.subtle {
      color: var(--muted);
      line-height: 1.6;
      font-size: 0.95rem;
    }

.status {
      color: var(--muted);
      font-size: 0.94rem;
      line-height: 1.5;
      padding: 2px 2px 0;
    }

label {
      display: block;
      margin-bottom: 8px;
      color: var(--muted);
      font-size: 0.95rem;
      font-weight: 600;
    }

input, select, button {
      width: 100%;
      padding: 13px 14px;
      border-radius: 16px;
      border: 1px solid var(--border);
      background: #121933;
      color: var(--text);
      font-size: 1rem;
      outline: none;
    }

input:focus,
    select:focus {
      border-color: rgba(124, 156, 255, 0.65);
      box-shadow: 0 0 0 4px rgba(124, 156, 255, 0.12);
    }

button {
      cursor: pointer;
      font-weight: 800;
      transition: 0.2s ease;
    }

button:hover {
      transform: translateY(-1px);
    }

.primary {
      background: linear-gradient(135deg, var(--accent), var(--accent-2));
      border: none;
      box-shadow: 0 14px 28px rgba(124, 156, 255, 0.25);
    }

.secondary {
      background: rgba(255, 255, 255, 0.06);
    }

.preview-title-row {
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 12px;
      flex-wrap: wrap;
      margin-bottom: 14px;
    }

.level-pill {
      display: inline-block;
      padding: 7px 11px;
      border-radius: 999px;
      border: 1px solid var(--border);
      background: var(--panel-strong);
      color: #dce5ff;
      font-size: 0.8rem;
      letter-spacing: 0.04em;
      font-weight: 700;
    }

.exercise {
      border: 1px solid var(--border);
      border-radius: 18px;
      padding: 16px;
      margin-top: 14px;
      background: rgba(255, 255, 255, 0.03);
    }

.exercise-head {
      display: flex;
      gap: 10px;
      justify-content: space-between;
      align-items: center;
      flex-wrap: wrap;
      margin-bottom: 10px;
    }

.tag {
      display: inline-block;
      font-size: 0.78rem;
      color: var(--tag-text);
      background: var(--tag-bg);
      border: 1px solid var(--tag-border);
      padding: 5px 9px;
      border-radius: 999px;
      font-weight: 700;
    }

.exercise-number {
      color: var(--muted);
      font-weight: 700;
      font-size: 0.95rem;
    }

.math {
      font-size: 1.08rem;
      line-height: 1.7;
      overflow-wrap: anywhere;
    }

.solutions-card.hidden {
      display: none;
    }

.footer-copy {
      margin-top: 28px;
      color: var(--muted);
      line-height: 1.7;
      font-size: 0.95rem;
    }

.hidden {
      display: none !important;
    }

#pdfArea {
      position: absolute;
      left: -99999px;
      top: 0;
      width: 794px;
      background: white;
      color: black;
      padding: 40px;
    }

.pdf-page {
      width: 100%;
      min-height: 1040px;
      padding: 10px 0 30px;
      background: white;
      color: black;
      page-break-after: always;
    }

.pdf-page:last-child {
      page-break-after: auto;
    }

.pdf-title {
      font-size: 28px;
      font-weight: 700;
      margin-bottom: 6px;
      color: black;
    }

.pdf-meta {
      font-size: 14px;
      color: #333;
      margin-bottom: 22px;
    }

.pdf-section-title {
      font-size: 20px;
      font-weight: 700;
      margin: 10px 0 18px;
      color: black;
    }

.pdf-exercise {
      border: 1px solid #d6d6d6;
      border-radius: 12px;
      padding: 12px 14px;
      margin-bottom: 12px;
      background: #fff;
      break-inside: avoid;
    }

.pdf-head {
      display: flex;
      justify-content: space-between;
      align-items: center;
      gap: 10px;
      margin-bottom: 8px;
      flex-wrap: wrap;
    }

.pdf-tag {
      display: inline-block;
      font-size: 11px;
      padding: 4px 8px;
      border-radius: 999px;
      background: #eef7f4;
      border: 1px solid #cbe9df;
      color: #165c4f;
      font-weight: 700;
    }

.pdf-num {
      color: #444;
      font-weight: 700;
      font-size: 13px;
    }

.pdf-math {
      color: black;
      font-size: 16px;
      line-height: 1.6;
    }

@media (max-width: 980px) {
      .hero {
        grid-template-columns: 1fr;
      }

.hero-badge {
        width: 72px;
        height: 72px;
        font-size: 32px;
      }

.grid {
        grid-template-columns: 1fr;
      }

.settings-card {
        position: static;
      }
    }
  </style>
</head>
<body>
  <div class="wrap">
    <section class="hero">
      <div class="hero-badge">∫</div>
      <div>
        <h1>Calculus Worksheet Generator</h1>
        <p>
          Generate beautiful practice sheets for integrals, derivatives, limits,
          numerical series, and mixed exam-style exercises. Every mathematical expression
          is rendered in LaTeX both on the page and inside the downloaded PDF.
        </p>
      </div>
    </section>

<div class="topic-nav" id="topicNav">
      <button data-topic="integrals" class="active">Integrals</button>
      <button data-topic="derivatives">Derivatives</button>
      <button data-topic="limits">Limits</button>
      <button data-topic="series">Series</button>
      <button data-topic="exam">Exam Mode</button>
    </div>

<div class="grid">
      <div class="card settings-card stack" id="settingsCard">
        <div>
          <h2>Settings</h2>
          <div class="subtle">Customize the worksheet and generate a fresh set of exercises instantly.</div>
        </div>

<div>
          <label for="title">Worksheet title</label>
          <input id="title" value="Integral Worksheet" />
        </div>

<div id="countWrap">
          <label for="count">Number of exercises</label>
          <input id="count" type="number" min="1" max="50" value="12" />
        </div>

<div>
          <label for="level">Difficulty</label>
          <select id="level">
            <option value="easy">Easy</option>
            <option value="medium" selected="">Medium</option>
            <option value="hard">Hard</option>
          </select>
        </div>

<button class="primary" id="generateBtn">Generate worksheet</button>
        <button class="secondary" id="toggleSolutionsBtn">Show solutions</button>
        <button class="secondary" id="downloadBtn">Download PDF</button>

<div class="status" id="status">Ready.</div>
      </div>

<div>
        <div class="card">
          <div class="preview-title-row">
            <h2 id="previewTitle" style="margin: 0;">Integral Worksheet</h2>
            <div class="level-pill" id="levelPill">MEDIUM</div>
          </div>
          <div id="exerciseList"></div>
        </div>

<div class="card solutions-card" id="solutionsCard" style="margin-top: 24px;">
          <div class="preview-title-row">
            <h2 style="margin: 0;">Solutions</h2>
            <div class="level-pill" id="solutionsPill">HIDDEN</div>
          </div>
          <div id="solutionList"></div>
        </div>
      </div>
    </div>

<div class="footer-copy">
      In Exam Mode, the generator creates one exercise for each topic:
      integrals, derivatives, limits, and series.
    </div>
  </div>

const choice = (arr) => {
      if (!Array.isArray(arr) || arr.length === 0) {
        throw new Error("Cannot choose from an empty array.");
      }
      return arr[Math.floor(Math.random() * arr.length)];
    };

function gcd(a, b) {
      a = Math.abs(a);
      b = Math.abs(b);
      while (b !== 0) {
        const t = b;
        b = a % b;
        a = t;
      }
      return a;
    }

function formatCoeff(value) {
      if (Number.isInteger(value)) return String(value);
      const rounded = Number(value.toFixed(2));
      if (Number.isInteger(rounded)) return String(rounded);
      const denom = 100;
      const num = Math.round(rounded * denom);
      return frac(num, denom);
    }

function withDisplayMath(latex) {
      return `\\[${latex}\\]`;
    }

function latexText(text) {
      return String(text)
        .replace(/\\/g, "\\\\")
        .replace(/%/g, "\\%")
        .replace(/_/g, "\\_")
        .replace(/&/g, "\\&")
        .replace(/#/g, "\\#");
    }

function shuffle(array) {
      const arr = [...array];
      for (let i = arr.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [arr[i], arr[j]] = [arr[j], arr[i]];
      }
      return arr;
    }

function buildPool(factory, size = 100) {
      const seen = new Set();
      const out = [];
      let attempts = 0;

while (out.length < size && attempts < size * 40) {
        attempts += 1;
        const ex = factory();
        const key = `${ex.q}=>${ex.s}`;
        if (seen.has(key)) continue;
        seen.add(key);
        out.push(ex);
      }
      return shuffle(out);
    }

function duplicateWithIndex(base, total) {
      return sampleExercises(base, total);
    }

function integralTemplates(level = "medium") {
      if (level === "easy") {
        return buildPool(() => {
          const a = randInt(1, 8);
          const b = randInt(1, 10);
          const c = randInt(1, 5);
          const d = randInt(1, 8);
          const k = randInt(1, 8);
          const m = randInt(1, 5);
          const p = randInt(2, 7);
          const q = randInt(2, 6);
          const type = randInt(1, 8);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\int (${a}x + ${b})\\,dx`),
                s: withDisplayMath(`${formatCoeff(a / 2)}x^2 + ${b}x + C`),
                tag: "Linear"
              };
            case 2:
              return {
                q: withDisplayMath(`\\int (${c}x^2 + ${d}x)\\,dx`),
                s: withDisplayMath(`${formatCoeff(c / 3)}x^3 + ${formatCoeff(d / 2)}x^2 + C`),
                tag: "Polynomial"
              };
            case 3:
              return {
                q: withDisplayMath(`\\int ${k}\\sin(x)\\,dx`),
                s: withDisplayMath(`${k === 1 ? "-" : "-" + k}\\cos(x) + C`),
                tag: "Trigonometric"
              };
            case 4:
              return {
                q: withDisplayMath(`\\int ${k}\\cos(x)\\,dx`),
                s: withDisplayMath(`${k}\\sin(x) + C`),
                tag: "Trigonometric"
              };
            case 5:
              return {
                q: withDisplayMath(`\\int ${m}e^x\\,dx`),
                s: withDisplayMath(`${m}e^x + C`),
                tag: "Exponential"
              };
            case 6:
              return {
                q: withDisplayMath(`\\int x^{${p}}\\,dx`),
                s: withDisplayMath(`\\frac{x^{${p + 1}}}{${p + 1}} + C`),
                tag: "Power rule"
              };
            case 7:
              return {
                q: withDisplayMath(`\\int \\frac{1}{x^{${q}}}\\,dx`),
                s: withDisplayMath(`\\frac{x^{${1 - q}}}{${1 - q}} + C`),
                tag: "Negative powers"
              };
            default:
              return {
                q: withDisplayMath(`\\int \\left(${a} + \\frac{${b}}{x}\\right)dx`),
                s: withDisplayMath(`${a}x + ${b}\\ln|x| + C`),
                tag: "Logarithmic"
              };
          }
        }, 140);
      }

if (level === "hard") {
        return buildPool(() => {
          const a = randInt(2, 6);
          const b = randInt(2, 6);
          const c = randInt(1, 5);
          const d = randInt(c + 1, c + 6);
          const type = randInt(1, 14);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\int xe^{${b}x}\\,dx`),
                s: withDisplayMath(`e^{${b}x}\\left(\\frac{x}{${b}} - \\frac{1}{${b * b}}\\right) + C`),
                tag: "By parts"
              };
            case 2:
              return {
                q: withDisplayMath(`\\int x^2\\sin(x)\\,dx`),
                s: withDisplayMath(`-x^2\\cos(x) + 2x\\sin(x) + 2\\cos(x) + C`),
                tag: "By parts"
              };
            case 3:
              return {
                q: withDisplayMath(`\\int x^2e^x\\,dx`),
                s: withDisplayMath(`e^x(x^2 - 2x + 2) + C`),
                tag: "By parts"
              };
            case 4:
              return {
                q: withDisplayMath(`\\int \\ln(x)\\,dx`),
                s: withDisplayMath(`x\\ln(x) - x + C`),
                tag: "Logarithmic"
              };
            case 5:
              return {
                q: withDisplayMath(`\\int \\frac{1}{1+x^2}\\,dx`),
                s: withDisplayMath(`\\arctan(x) + C`),
                tag: "Inverse trig"
              };
            case 6:
              return {
                q: withDisplayMath(`\\int e^x\\sin(x)\\,dx`),
                s: withDisplayMath(`\\frac{e^x(\\sin(x)-\\cos(x))}{2} + C`),
                tag: "Repeated parts"
              };
            case 7:
              return {
                q: withDisplayMath(`\\int \\frac{${a}x}{1+x^2}\\,dx`),
                s: withDisplayMath(`${frac(a, 2)}\\ln(1+x^2) + C`),
                tag: "Substitution"
              };
            case 8:
              return {
                q: withDisplayMath(`\\int \\frac{1}{x\\ln(x)}\\,dx`),
                s: withDisplayMath(`\\ln|\\ln(x)| + C`),
                tag: "Log substitution"
              };
            case 9:
              return {
                q: withDisplayMath(`\\int \\frac{1}{(x+${c})(x+${d})}\\,dx`),
                s: withDisplayMath(`\\frac{1}{${d - c}}\\ln\\left|\\frac{x+${c}}{x+${d}}\\right| + C`),
                tag: "Partial fractions"
              };
            case 10:
              return {
                q: withDisplayMath(`\\int \\frac{dx}{\\sqrt{${a * a}-x^2}}`),
                s: withDisplayMath(`\\arcsin\\left(\\frac{x}{${a}}\\right) + C`),
                tag: "Inverse trig"
              };
            case 11:
              return {
                q: withDisplayMath(`\\int \\frac{x^2+${c}x+${d}}{x+1}\\,dx`),
                s: withDisplayMath(`\\frac{x^2}{2} + (${c - 1})x + (${d - c + 1})\\ln|x+1| + C`),
                tag: "Division + log"
              };
            case 12:
              return {
                q: withDisplayMath(`\\int \\tan(x)\\,dx`),
                s: withDisplayMath(`-\\ln|\\cos(x)| + C`),
                tag: "Trigonometric"
              };
            case 13:
              return {
                q: withDisplayMath(`\\int \\sec^2(${a}x)\\,dx`),
                s: withDisplayMath(`\\frac{1}{${a}}\\tan(${a}x) + C`),
                tag: "Trigonometric"
              };
            default:
              return {
                q: withDisplayMath(`\\int \\frac{1}{x^2-${a * a}}\\,dx`),
                s: withDisplayMath(`\\frac{1}{${2 * a}}\\ln\\left|\\frac{x-${a}}{x+${a}}\\right| + C`),
                tag: "Partial fractions"
              };
          }
        }, 140);
      }

return buildPool(() => {
        const a = randInt(1, 5);
        const b = randInt(1, 6);
        const c = randInt(1, 4);
        const d = randInt(1, 6);
        const p = randInt(2, 5);
        const type = randInt(1, 12);

switch (type) {
          case 1:
            return {
              q: withDisplayMath(`\\int (${a}x + ${b})^2\\,dx`),
              s: withDisplayMath(`\\frac{(${a}x + ${b})^3}{${3 * a}} + C`),
              tag: "Substitution"
            };
          case 2:
            return {
              q: withDisplayMath(`\\int xe^x\\,dx`),
              s: withDisplayMath(`e^x(x - 1) + C`),
              tag: "By parts"
            };
          case 3:
            return {
              q: withDisplayMath(`\\int x\\sin(x)\\,dx`),
              s: withDisplayMath(`-x\\cos(x) + \\sin(x) + C`),
              tag: "By parts"
            };
          case 4:
            return {
              q: withDisplayMath(`\\int x\\cos(x)\\,dx`),
              s: withDisplayMath(`x\\sin(x) + \\cos(x) + C`),
              tag: "By parts"
            };
          case 5:
            return {
              q: withDisplayMath(`\\int \\frac{1}{${c}x + ${d}}\\,dx`),
              s: withDisplayMath(`\\frac{1}{${c}}\\ln|${c}x + ${d}| + C`),
              tag: "Logarithmic"
            };
          case 6:
            return {
              q: withDisplayMath(`\\int (\\sin(x) + x^2)\\,dx`),
              s: withDisplayMath(`-\\cos(x) + \\frac{x^3}{3} + C`),
              tag: "Mixed"
            };
          case 7:
            return {
              q: withDisplayMath(`\\int x(${a}x+${b})^${p}\\,dx`),
              s: withDisplayMath(`\\text{Use }u=${a}x+${b}`),
              tag: "Substitution"
            };
          case 8:
            return {
              q: withDisplayMath(`\\int \\sec^2(${a}x)\\,dx`),
              s: withDisplayMath(`\\frac{1}{${a}}\\tan(${a}x) + C`),
              tag: "Trigonometric"
            };
          case 9:
            return {
              q: withDisplayMath(`\\int \\frac{x}{x^2+${d}}\\,dx`),
              s: withDisplayMath(`\\frac{1}{2}\\ln(x^2+${d}) + C`),
              tag: "Substitution"
            };
          case 10:
            return {
              q: withDisplayMath(`\\int e^{${a}x}\\,dx`),
              s: withDisplayMath(`\\frac{1}{${a}}e^{${a}x} + C`),
              tag: "Exponential"
            };
          case 11:
            return {
              q: withDisplayMath(`\\int \\frac{1}{\\sqrt{x}}\\,dx`),
              s: withDisplayMath(`2\\sqrt{x} + C`),
              tag: "Power rule"
            };
          default:
            return {
              q: withDisplayMath(`\\int \\frac{1}{x^2+${a * a}}\\,dx`),
              s: withDisplayMath(`\\frac{1}{${a}}\\arctan\\left(\\frac{x}{${a}}\\right) + C`),
              tag: "Inverse trig"
            };
        }
      }, 140);
    }

function derivativeTemplates(level = "medium") {
      if (level === "easy") {
        return buildPool(() => {
          const a = randInt(1, 8);
          const b = randInt(1, 6);
          const p = randInt(2, 6);
          const type = randInt(1, 9);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(${a}x^2)`),
                s: withDisplayMath(`${2 * a}x`),
                tag: "Polynomial"
              };
            case 2:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(${b}x^${p})`),
                s: withDisplayMath(`${b * p}x^${p - 1}`),
                tag: "Power rule"
              };
            case 3:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\sin(x))`),
                s: withDisplayMath(`\\cos(x)`),
                tag: "Trigonometric"
              };
            case 4:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\cos(x))`),
                s: withDisplayMath(`-\\sin(x)`),
                tag: "Trigonometric"
              };
            case 5:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(e^x)`),
                s: withDisplayMath(`e^x`),
                tag: "Exponential"
              };
            case 6:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\ln(x))`),
                s: withDisplayMath(`\\frac{1}{x}`),
                tag: "Logarithmic"
              };
            case 7:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\sqrt{x})`),
                s: withDisplayMath(`\\frac{1}{2\\sqrt{x}}`),
                tag: "Roots"
              };
            case 8:
              return {
                q: withDisplayMath(`\\frac{d}{dx}\\left(\\frac{1}{x}\\right)`),
                s: withDisplayMath(`-\\frac{1}{x^2}`),
                tag: "Negative powers"
              };
            default:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(${a}x + ${b})`),
                s: withDisplayMath(`${a}`),
                tag: "Linear"
              };
          }
        }, 120);
      }

if (level === "hard") {
        return buildPool(() => {
          const a = randInt(2, 6);
          const b = randInt(2, 5);
          const type = randInt(1, 12);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(e^{x^2})`),
                s: withDisplayMath(`2xe^{x^2}`),
                tag: "Chain rule"
              };
            case 2:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\ln(x^2+1))`),
                s: withDisplayMath(`\\frac{2x}{x^2+1}`),
                tag: "Chain rule"
              };
            case 3:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\sin(x^2))`),
                s: withDisplayMath(`2x\\cos(x^2)`),
                tag: "Chain rule"
              };
            case 4:
              return {
                q: withDisplayMath(`\\frac{d}{dx}\\left(\\frac{x^2+1}{x-1}\\right)`),
                s: withDisplayMath(`\\frac{x^2-2x-1}{(x-1)^2}`),
                tag: "Quotient rule"
              };
            case 5:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(x^x)`),
                s: withDisplayMath(`x^x(\\ln(x)+1)`),
                tag: "Log differentiation"
              };
            case 6:
              return {
                q: withDisplayMath(`\\frac{d}{dx}\\left((${a}x+${b})^${b}\\right)`),
                s: withDisplayMath(`${a * b}(${a}x+${b})^${b - 1}`),
                tag: "Chain rule"
              };
            case 7:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\tan(${a}x))`),
                s: withDisplayMath(`${a}\\sec^2(${a}x)`),
                tag: "Trigonometric"
              };
            case 8:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(x^2e^x)`),
                s: withDisplayMath(`e^x(x^2+2x)`),
                tag: "Product rule"
              };
            case 9:
              return {
                q: withDisplayMath(`\\frac{d}{dx}\\left(\\frac{\\ln(x)}{x}\\right)`),
                s: withDisplayMath(`\\frac{1-\\ln(x)}{x^2}`),
                tag: "Quotient rule"
              };
            case 10:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\arctan(x))`),
                s: withDisplayMath(`\\frac{1}{1+x^2}`),
                tag: "Inverse trig"
              };
            case 11:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(\\sqrt{1+x^2})`),
                s: withDisplayMath(`\\frac{x}{\\sqrt{1+x^2}}`),
                tag: "Chain rule"
              };
            default:
              return {
                q: withDisplayMath(`\\frac{d}{dx}(e^x\\sin(x))`),
                s: withDisplayMath(`e^x(\\sin(x)+\\cos(x))`),
                tag: "Product rule"
              };
          }
        }, 120);
      }

return buildPool(() => {
        const a = randInt(2, 6);
        const type = randInt(1, 12);

switch (type) {
          case 1:
            return {
              q: withDisplayMath(`\\frac{d}{dx}\\left((x^2+1)e^x\\right)`),
              s: withDisplayMath(`e^x(x^2+2x+1)`),
              tag: "Product rule"
            };
          case 2:
            return {
              q: withDisplayMath(`\\frac{d}{dx}((3x+1)^4)`),
              s: withDisplayMath(`12(3x+1)^3`),
              tag: "Chain rule"
            };
          case 3:
            return {
              q: withDisplayMath(`\\frac{d}{dx}(x\\sin(x))`),
              s: withDisplayMath(`\\sin(x)+x\\cos(x)`),
              tag: "Product rule"
            };
          case 4:
            return {
              q: withDisplayMath(`\\frac{d}{dx}\\left(\\frac{1}{x^2+1}\\right)`),
              s: withDisplayMath(`\\frac{-2x}{(x^2+1)^2}`),
              tag: "Quotient rule"
            };
          case 5:
            return {
              q: withDisplayMath(`\\frac{d}{dx}(\\ln(x))`),
              s: withDisplayMath(`\\frac{1}{x}`),
              tag: "Logarithmic"
            };
          case 6:
            return {
              q: withDisplayMath(`\\frac{d}{dx}(\\arctan(x))`),
              s: withDisplayMath(`\\frac{1}{1+x^2}`),
              tag: "Inverse trig"
            };
          case 7:
            return {
              q: withDisplayMath(`\\frac{d}{dx}(e^{${a}x})`),
              s: withDisplayMath(`${a}e^{${a}x}`),
              tag: "Exponential"
            };
          case 8:
            return {
              q: withDisplayMath(`\\frac{d}{dx}(\\sqrt{1+x^2})`),
              s: withDisplayMath(`\\frac{x}{\\sqrt{1+x^2}}`),
              tag: "Chain rule"
            };
          case 9:
            return {
              q: withDisplayMath(`\\frac{d}{dx}(x\\cos(x))`),
              s: withDisplayMath(`\\cos(x)-x\\sin(x)`),
              tag: "Product rule"
            };
          case 10:
            return {
              q: withDisplayMath(`\\frac{d}{dx}(\\tan(x))`),
              s: withDisplayMath(`\\sec^2(x)`),
              tag: "Trigonometric"
            };
          case 11:
            return {
              q: withDisplayMath(`\\frac{d}{dx}(x^2\\ln(x))`),
              s: withDisplayMath(`2x\\ln(x)+x`),
              tag: "Product rule"
            };
          default:
            return {
              q: withDisplayMath(`\\frac{d}{dx}\\left(\\frac{x}{x^2+1}\\right)`),
              s: withDisplayMath(`\\frac{1-x^2}{(x^2+1)^2}`),
              tag: "Quotient rule"
            };
        }
      }, 120);
    }

function limitTemplates(level = "medium") {
      if (level === "easy") {
        return duplicateWithIndex([
          { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{\\sin(x)}{x}`), s: withDisplayMath(`1`), tag: "Notable limit" },
          { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{1-\\cos(x)}{x^2}`), s: withDisplayMath(`\\frac{1}{2}`), tag: "Notable limit" },
          { q: withDisplayMath(`\\lim_{x\\to \\infty}\\frac{1}{x}`), s: withDisplayMath(`0`), tag: "Basic" },
          { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{e^x-1}{x}`), s: withDisplayMath(`1`), tag: "Notable limit" },
          { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{\\ln(1+x)}{x}`), s: withDisplayMath(`1`), tag: "Notable limit" }
        ], 60);
      }

if (level === "hard") {
        return duplicateWithIndex([
          { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{\\sin(3x)}{x}`), s: withDisplayMath(`3`), tag: "Notable limit" },
          { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{e^{2x}-1}{x}`), s: withDisplayMath(`2`), tag: "Notable limit" },
          { q: withDisplayMath(`\\lim_{x\\to \\infty}(\\sqrt{x^2+1}-x)`), s: withDisplayMath(`0`), tag: "Rationalization" },
          { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{(1+x)^5-1}{x}`), s: withDisplayMath(`5`), tag: "Expansion" },
          { q: withDisplayMath(`\\lim_{x\\to \\infty}\\frac{x^2+3x}{2x^2-1}`), s: withDisplayMath(`\\frac{1}{2}`), tag: "Rational" }
        ], 60);
      }

return duplicateWithIndex([
        { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{\\tan(x)}{x}`), s: withDisplayMath(`1`), tag: "Notable limit" },
        { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{\\ln(1+x)}{x}`), s: withDisplayMath(`1`), tag: "Notable limit" },
        { q: withDisplayMath(`\\lim_{x\\to \\infty}\\frac{2x^2+1}{x^2-3}`), s: withDisplayMath(`2`), tag: "Rational" },
        { q: withDisplayMath(`\\lim_{x\\to 0}\\frac{\\sqrt{1+x}-1}{x}`), s: withDisplayMath(`\\frac{1}{2}`), tag: "Algebraic" },
        { q: withDisplayMath(`\\lim_{x\\to \\infty}\\frac{3x+1}{x^2+2}`), s: withDisplayMath(`0`), tag: "Rational" }
      ], 60);
    }

function seriesTemplates(level = "medium") {
      if (level === "easy") {
        return duplicateWithIndex([
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{1}{n^2} \\text{ converges}`), s: withDisplayMath(`\\text{Convergent}`), tag: "p-series" },
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{1}{n} \\text{ converges}`), s: withDisplayMath(`\\text{Divergent}`), tag: "Harmonic" },
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{1}{2^n} \\text{ converges}`), s: withDisplayMath(`\\text{Convergent}`), tag: "Geometric" },
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{3^n}{4^n} \\text{ converges}`), s: withDisplayMath(`\\text{Convergent}`), tag: "Geometric" }
        ], 60);
      }

if (level === "hard") {
        return duplicateWithIndex([
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{n!}{n^n} \\text{ converges}`), s: withDisplayMath(`\\text{Convergent}`), tag: "Ratio/root style" },
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{n^2+1}{n^3+2} \\text{ converges}`), s: withDisplayMath(`\\text{Divergent}`), tag: "Comparison" },
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{(-1)^n}{n^2} \\text{ converges}`), s: withDisplayMath(`\\text{Absolutely convergent}`), tag: "Absolute convergence" },
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{2^n}{n!} \\text{ converges}`), s: withDisplayMath(`\\text{Convergent}`), tag: "Ratio test" },
          { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{\\ln(n)}{n} \\text{ converges}`), s: withDisplayMath(`\\text{Divergent}`), tag: "Comparison/integral" }
        ], 60);
      }

return duplicateWithIndex([
        { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{1}{n^{3/2}} \\text{ converges}`), s: withDisplayMath(`\\text{Convergent}`), tag: "p-series" },
        { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{n}{n^2+1} \\text{ converges}`), s: withDisplayMath(`\\text{Divergent}`), tag: "Comparison" },
        { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{1}{n(n+1)} \\text{ converges}`), s: withDisplayMath(`\\text{Convergent}`), tag: "Telescoping" },
        { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{(-1)^n}{n} \\text{ converges}`), s: withDisplayMath(`\\text{Conditionally convergent}`), tag: "Alternating" },
        { q: withDisplayMath(`\\text{Determine whether } \\sum \\frac{1}{n\\ln n} \\text{ converges}`), s: withDisplayMath(`\\text{Divergent}`), tag: "Integral test" }
      ], 60);
    }

function generatorForTopic(topic, level) {
      switch (topic) {
        case "integrals": return integralTemplates(level);
        case "derivatives": return derivativeTemplates(level);
        case "limits": return limitTemplates(level);
        case "series": return seriesTemplates(level);
        default: return [];
      }
    }

function buildExercises(topic, count, level) {
      const pool = generatorForTopic(topic, level);
      return sampleExercises(pool, count);
    }

let currentTopic = "integrals";
    let solutionsVisible = false;
    let currentExercises = [];

function defaultTitleForTopic(topic) {
      switch (topic) {
        case "integrals": return "Integral Worksheet";
        case "derivatives": return "Derivative Worksheet";
        case "limits": return "Limits Worksheet";
        case "series": return "Series Worksheet";
        case "exam": return "Calculus Exam Practice";
        default: return "Worksheet";
      }
    }

function updateTopicButtons() {
      document.querySelectorAll("#topicNav button").forEach((btn) => {
        btn.classList.toggle("active", btn.dataset.topic === currentTopic);
      });
    }

function updatePills() {
      const level = document.getElementById("level").value;
      document.getElementById("levelPill").textContent = level.toUpperCase();
      document.getElementById("solutionsPill").textContent = solutionsVisible ? "VISIBLE" : "HIDDEN";
    }

async function typesetMath(elements) {
      if (window.MathJax && window.MathJax.typesetPromise) {
        await window.MathJax.typesetPromise(elements);
      }
    }

async function renderLists() {
      const exerciseList = document.getElementById("exerciseList");
      const solutionList = document.getElementById("solutionList");
      const solutionsCard = document.getElementById("solutionsCard");

exerciseList.innerHTML = "";
      solutionList.innerHTML = "";

currentExercises.forEach((ex) => {
        const tag = ex.examTopic ? ex.examTopic.toUpperCase() : ex.tag;

solutionsCard.classList.toggle("hidden", !solutionsVisible);
      updatePills();
      await typesetMath([exerciseList, solutionList]);
    }

async function generateWorksheet() {
      const titleInput = document.getElementById("title");
      const countInput = document.getElementById("count");
      const levelSelect = document.getElementById("level");
      const previewTitle = document.getElementById("previewTitle");
      const status = document.getElementById("status");

const count = Math.max(1, Math.min(50, Number(countInput.value) || 10));
      countInput.value = count;

const level = levelSelect.value;
      const title = titleInput.value.trim() || defaultTitleForTopic(currentTopic);

previewTitle.textContent = title;

currentExercises =
        currentTopic === "exam"
          ? buildExamSheet(level)
          : buildExercises(currentTopic, count, level);

await renderLists();

status.textContent =
        currentTopic === "exam"
          ? `Generated ${currentExercises.length} exam exercises.`
          : `Generated ${currentExercises.length} exercises.`;
    }

async function setTopic(topic) {
      currentTopic = topic;

const titleInput = document.getElementById("title");
      const countWrap = document.getElementById("countWrap");
      const status = document.getElementById("status");

titleInput.value = defaultTitleForTopic(topic);
      countWrap.classList.toggle("hidden", topic === "exam");

updateTopicButtons();
      solutionsVisible = false;
      document.getElementById("toggleSolutionsBtn").textContent = "Show solutions";
      status.textContent = "Ready.";

await generateWorksheet();
    }

return `
        <div class="pdf-page">
          <div class="pdf-title">${title}</div>
          <div class="pdf-meta">${pdfLevel}</div>
          <div class="pdf-section-title">${pdfExercises}</div>
          ${exerciseHtml}
        </div>
        ${solutionsVisible ? `
        <div class="pdf-page">
          <div class="pdf-title">${title}</div>
          <div class="pdf-meta">${pdfSolutions}</div>
          <div class="pdf-section-title">${pdfSolutions}</div>
          ${solutionHtml}
        </div>` : ""}
      `;
    }

async function downloadPdf() {
      const status = document.getElementById("status");
      const pdfArea = document.getElementById("pdfArea");
      const title = document.getElementById("previewTitle").textContent || "worksheet";

try {
        status.textContent = "Preparing PDF...";
        pdfArea.innerHTML = buildPdfMarkup();
        await typesetMath([pdfArea]);

const pages = Array.from(pdfArea.querySelectorAll(".pdf-page"));
        const { jsPDF } = window.jspdf;
        const pdf = new jsPDF({ orientation: "p", unit: "mm", format: "a4" });
        const pageWidth = pdf.internal.pageSize.getWidth();
        const pageHeight = pdf.internal.pageSize.getHeight();

for (let i = 0; i < pages.length; i++) {
          const canvas = await html2canvas(pages[i], {
            scale: 2,
            useCORS: true,
            backgroundColor: "#ffffff"
          });

const imgData = canvas.toDataURL("image/png");
          const imgWidth = pageWidth;
          const imgHeight = (canvas.height * imgWidth) / canvas.width;

if (i > 0) pdf.addPage();
          pdf.addImage(imgData, "PNG", 0, 0, imgWidth, Math.min(imgHeight, pageHeight));
        }

const safeName = title
          .toLowerCase()
          .replace(/[^a-z0-9]+/g, "-")
          .replace(/^-+|-+$/g, "") || "worksheet";

pdf.save(`${safeName}.pdf`);
        status.textContent = "PDF downloaded successfully.";
      } catch (err) {
        status.textContent = "PDF generation failed.";
        console.error(err);
      }
    }

document.getElementById("generateBtn").addEventListener("click", generateWorksheet);

document.getElementById("toggleSolutionsBtn").addEventListener("click", async () => {
      solutionsVisible = !solutionsVisible;
      document.getElementById("toggleSolutionsBtn").textContent =
        solutionsVisible ? "Hide solutions" : "Show solutions";
      await renderLists();
    });

document.getElementById("downloadBtn").addEventListener("click", downloadPdf);
    document.getElementById("level").addEventListener("change", async () => {
      updatePills();
      await generateWorksheet();
    });

document.querySelectorAll("#topicNav button").forEach((btn) => {
      btn.addEventListener("click", () => setTopic(btn.dataset.topic));
    });

setTopic("integrals");
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Calculus II Generator</title>
  <meta name="description" content="Calculus II worksheet generator for multivariable limits, multiple integrals, directional derivatives, differentiability, and exam-mode practice." />

* { box-sizing: border-box; }

body {
      margin: 0;
      font-family: Inter, Arial, sans-serif;
      color: var(--text);
      background:
        radial-gradient(circle at top left, rgba(121, 168, 255, 0.20), transparent 28%),
        radial-gradient(circle at top right, rgba(142, 120, 255, 0.16), transparent 30%),
        linear-gradient(180deg, var(--bg-1) 0%, var(--bg-2) 100%);
      min-height: 100vh;
    }

.wrap {
      max-width: 1260px;
      margin: 0 auto;
      padding: 28px;
    }

.hero {
      display: grid;
      grid-template-columns: 88px 1fr;
      gap: 18px;
      align-items: center;
      margin-bottom: 24px;
    }

.hero-badge {
      width: 88px;
      height: 88px;
      border-radius: 26px;
      display: grid;
      place-items: center;
      font-size: 30px;
      font-weight: 800;
      background: linear-gradient(135deg, var(--accent), var(--accent-2));
      box-shadow: 0 18px 44px rgba(121, 168, 255, 0.28);
    }

.hero h1 {
      margin: 0 0 10px;
      font-size: clamp(2rem, 4.5vw, 3.5rem);
      line-height: 1.02;
      letter-spacing: -0.03em;
    }

.hero p {
      margin: 0;
      color: var(--muted);
      line-height: 1.75;
      max-width: 980px;
      font-size: 1.03rem;
    }

.topic-nav {
      display: flex;
      gap: 10px;
      flex-wrap: wrap;
      margin: 20px 0 28px;
    }

.topic-nav button:hover {
      transform: translateY(-1px);
      color: var(--text);
    }

.topic-nav button.active {
      background: linear-gradient(135deg, var(--accent), var(--accent-2));
      color: white;
      border: none;
      box-shadow: 0 14px 30px rgba(121, 168, 255, 0.22);
    }

.grid {
      display: grid;
      grid-template-columns: 360px 1fr;
      gap: 24px;
      align-items: start;
    }

.settings-card {
      position: sticky;
      top: 18px;
    }

.stack > * + * {
      margin-top: 16px;
    }

.card h2 {
      margin: 0 0 6px;
      font-size: 1.2rem;
    }

.subtle {
      color: var(--muted);
      line-height: 1.6;
      font-size: 0.95rem;
    }

.status {
      color: var(--muted);
      font-size: 0.94rem;
      line-height: 1.5;
      padding: 2px 2px 0;
    }

label {
      display: block;
      margin-bottom: 8px;
      color: var(--muted);
      font-size: 0.95rem;
      font-weight: 600;
    }

input:focus, select:focus {
      border-color: rgba(121, 168, 255, 0.65);
      box-shadow: 0 0 0 4px rgba(121, 168, 255, 0.12);
    }

button {
      cursor: pointer;
      font-weight: 800;
      transition: 0.2s ease;
    }

button:hover {
      transform: translateY(-1px);
    }

.primary {
      background: linear-gradient(135deg, var(--accent), var(--accent-2));
      border: none;
      box-shadow: 0 14px 28px rgba(121, 168, 255, 0.25);
    }

.secondary {
      background: rgba(255, 255, 255, 0.06);
    }

.preview-title-row {
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 12px;
      flex-wrap: wrap;
      margin-bottom: 14px;
    }

.exercise {
      border: 1px solid var(--border);
      border-radius: 18px;
      padding: 16px;
      margin-top: 14px;
      background: rgba(255, 255, 255, 0.03);
    }

.exercise-head {
      display: flex;
      gap: 10px;
      justify-content: space-between;
      align-items: center;
      flex-wrap: wrap;
      margin-bottom: 10px;
    }

.exercise-number {
      color: var(--muted);
      font-weight: 700;
      font-size: 0.95rem;
    }

.math {
      font-size: 1.08rem;
      line-height: 1.75;
      overflow-wrap: anywhere;
    }

.solutions-card.hidden {
      display: none;
    }

.footer-copy {
      margin-top: 28px;
      color: var(--muted);
      line-height: 1.7;
      font-size: 0.95rem;
    }

.hidden {
      display: none !important;
    }

#pdfArea {
      position: absolute;
      left: -99999px;
      top: 0;
      width: 794px;
      background: white;
      color: black;
      padding: 40px;
    }

.pdf-page {
      width: 100%;
      min-height: 1040px;
      padding: 10px 0 30px;
      background: white;
      color: black;
      page-break-after: always;
    }

.pdf-page:last-child {
      page-break-after: auto;
    }

.pdf-title {
      font-size: 28px;
      font-weight: 700;
      margin-bottom: 6px;
      color: black;
    }

.pdf-meta {
      font-size: 14px;
      color: #333;
      margin-bottom: 22px;
    }

.pdf-section-title {
      font-size: 20px;
      font-weight: 700;
      margin: 10px 0 18px;
      color: black;
    }

.pdf-exercise {
      border: 1px solid #d6d6d6;
      border-radius: 12px;
      padding: 12px 14px;
      margin-bottom: 12px;
      background: #fff;
      break-inside: avoid;
    }

.pdf-head {
      display: flex;
      justify-content: space-between;
      align-items: center;
      gap: 10px;
      margin-bottom: 8px;
      flex-wrap: wrap;
    }

.pdf-num {
      color: #444;
      font-weight: 700;
      font-size: 13px;
    }

.pdf-math {
      color: black;
      font-size: 16px;
      line-height: 1.6;
    }

@media (max-width: 980px) {
      .hero { grid-template-columns: 1fr; }
      .hero-badge { width: 72px; height: 72px; font-size: 28px; }
      .grid { grid-template-columns: 1fr; }
      .settings-card { position: static; }
    }
  </style>
</head>
<body>
  <div class="wrap">
    <section class="hero">
      <div class="hero-badge">∇</div>
      <div>
        <h1>Calculus II Generator</h1>
        <p>
          Generate university-style practice sheets for multivariable limits, multiple integrals,
          directional derivatives, differentiability, and mixed exam-mode training. Every mathematical
          expression is rendered in LaTeX both on the page and inside the downloaded PDF.
        </p>
      </div>
    </section>

<div class="topic-nav" id="topicNav">
      <button data-topic="multivariable-limits" class="active">Multivariable Limits</button>
      <button data-topic="multiple-integrals">Multiple Integrals</button>
      <button data-topic="directional-derivatives">Directional Derivatives</button>
      <button data-topic="differentiability">Differentiability</button>
      <button data-topic="exam">Exam Mode</button>
    </div>

<div class="grid">
      <div class="card settings-card stack">
        <div>
          <h2>Settings</h2>
          <div class="subtle">Choose a topic, difficulty, and generate a fresh university-style worksheet instantly.</div>
        </div>

<div>
          <label for="title">Worksheet title</label>
          <input id="title" value="Calculus II Worksheet" />
        </div>

<div id="countWrap">
          <label for="count">Number of exercises</label>
          <input id="count" type="number" min="1" max="50" value="10" />
        </div>

<div class="status" id="status">Ready.</div>
      </div>

<div>
        <div class="card">
          <div class="preview-title-row">
            <h2 id="previewTitle" style="margin: 0;">Calculus II Worksheet</h2>
            <div class="level-pill" id="levelPill">MEDIUM</div>
          </div>
          <div id="exerciseList"></div>
        </div>

<div class="card solutions-card hidden" id="solutionsCard" style="margin-top: 24px;">
          <div class="preview-title-row">
            <h2 style="margin: 0;">Solutions</h2>
            <div class="level-pill" id="solutionsPill">HIDDEN</div>
          </div>
          <div id="solutionList"></div>
        </div>
      </div>
    </div>

<div class="footer-copy">
      In Exam Mode, the generator creates one exercise for each topic: multivariable limits, multiple integrals,
      directional derivatives, and differentiability.
    </div>
  </div>

function gcd(a, b) {
      a = Math.abs(a);
      b = Math.abs(b);
      while (b !== 0) {
        const t = b;
        b = a % b;
        a = t;
      }
      return a;
    }

function withDisplayMath(latex) {
      return `\\[${latex}\\]`;
    }

function buildPool(factory, size = 120) {
      const seen = new Set();
      const out = [];
      let attempts = 0;

while (out.length < size && attempts < size * 45) {
        attempts += 1;
        const ex = factory();
        const key = `${ex.q}=>${ex.s}`;
        if (seen.has(key)) continue;
        seen.add(key);
        out.push(ex);
      }
      return shuffle(out);
    }

function multivariableLimitTemplates(level = "medium") {
      if (level === "easy") {
        return buildPool(() => {
          const a = randInt(1, 5);
          const b = randInt(1, 5);
          const c = randInt(1, 4);
          const type = randInt(1, 8);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2+y^2}{\\sqrt{x^2+y^2}}`),
                s: withDisplayMath(`0`),
                tag: "Polar coordinates"
              };
            case 2:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2y^2}{x^2+y^2}`),
                s: withDisplayMath(`0`),
                tag: "Squeeze theorem"
              };
            case 3:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{${a}xy}{x^2+y^2}`),
                s: withDisplayMath(`\\text{Does not exist}`),
                tag: "Path dependence"
              };
            case 4:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2y}{x^2+y^2}`),
                s: withDisplayMath(`0`),
                tag: "Polar coordinates"
              };
            case 5:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2+y^2}{${b}+x^2+y^2}`),
                s: withDisplayMath(`0`),
                tag: "Continuity"
              };
            case 6:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^4+y^4}{x^2+y^2}`),
                s: withDisplayMath(`0`),
                tag: "Degree comparison"
              };
            case 7:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{\\sin(x^2+y^2)}{x^2+y^2}`),
                s: withDisplayMath(`1`),
                tag: "Notable limit"
              };
            default:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2-${c}y^2}{x^2+y^2}`),
                s: withDisplayMath(`\\text{Does not exist}`),
                tag: "Path dependence"
              };
          }
        }, 120);
      }

if (level === "hard") {
        return buildPool(() => {
          const a = randInt(1, 5);
          const b = randInt(2, 6);
          const type = randInt(1, 10);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2y^2}{(x^2+y^2)^{3/2}}`),
                s: withDisplayMath(`0`),
                tag: "Polar coordinates"
              };
            case 2:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^3-y^3}{x^2+y^2}`),
                s: withDisplayMath(`0`),
                tag: "Order estimate"
              };
            case 3:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2y}{x^4+y^2}`),
                s: withDisplayMath(`\\text{Does not exist}`),
                tag: "Curved path"
              };
            case 4:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^{${b}}+y^{${b}}}{\\sqrt{x^2+y^2}}`),
                s: withDisplayMath(`0`),
                tag: "Degree comparison"
              };
            case 5:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2-y^2}{\\sqrt{x^2+y^2}}`),
                s: withDisplayMath(`0`),
                tag: "Polar coordinates"
              };
            case 6:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^4+a y^4}{x^2+y^2}`.replace('a', String(a))),
                s: withDisplayMath(`0`),
                tag: "Order estimate"
              };
            case 7:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2y^2}{x^4+y^4}`),
                s: withDisplayMath(`\\text{Does not exist}`),
                tag: "Path dependence"
              };
            case 8:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{e^{x^2+y^2}-1}{x^2+y^2}`),
                s: withDisplayMath(`1`),
                tag: "Expansion"
              };
            case 9:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{\\ln(1+x^2+y^2)}{x^2+y^2}`),
                s: withDisplayMath(`1`),
                tag: "Expansion"
              };
            default:
              return {
                q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{xy}{\\sqrt{x^2+y^2}}`),
                s: withDisplayMath(`0`),
                tag: "Polar coordinates"
              };
          }
        }, 120);
      }

return buildPool(() => {
        const a = randInt(1, 4);
        const type = randInt(1, 10);

switch (type) {
          case 1:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2y}{x^2+y^2}`),
              s: withDisplayMath(`0`),
              tag: "Polar coordinates"
            };
          case 2:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{xy}{x^2+y^2}`),
              s: withDisplayMath(`\\text{Does not exist}`),
              tag: "Path dependence"
            };
          case 3:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^3+y^3}{x^2+y^2}`),
              s: withDisplayMath(`0`),
              tag: "Degree comparison"
            };
          case 4:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{\\sin(x^2+y^2)}{x^2+y^2}`),
              s: withDisplayMath(`1`),
              tag: "Notable limit"
            };
          case 5:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2-${a}y^2}{x^2+y^2}`),
              s: withDisplayMath(`\\text{Does not exist}`),
              tag: "Path dependence"
            };
          case 6:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^2y^2}{x^2+y^2}`),
              s: withDisplayMath(`0`),
              tag: "Squeeze theorem"
            };
          case 7:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{\\sqrt{1+x^2+y^2}-1}{x^2+y^2}`),
              s: withDisplayMath(`\\frac{1}{2}`),
              tag: "Rationalization"
            };
          case 8:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{e^{x^2+y^2}-1}{x^2+y^2}`),
              s: withDisplayMath(`1`),
              tag: "Expansion"
            };
          case 9:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{x^4+y^4}{x^2+y^2}`),
              s: withDisplayMath(`0`),
              tag: "Degree comparison"
            };
          default:
            return {
              q: withDisplayMath(`\\lim_{(x,y)\\to(0,0)} \\frac{|x|y^2}{x^2+y^2}`),
              s: withDisplayMath(`0`),
              tag: "Estimate"
            };
          }
      }, 120);
    }

function multipleIntegralTemplates(level = "medium") {
      if (level === "easy") {
        return buildPool(() => {
          const a = randInt(1, 4);
          const b = randInt(1, 4);
          const type = randInt(1, 8);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\iint_{[0,${a}]\\times[0,${b}]} (x+y)\\,dA`),
                s: withDisplayMath(`\\frac{${a * a * b}}{2}+\\frac{${a * b * b}}{2}`),
                tag: "Rectangular region"
              };
            case 2:
              return {
                q: withDisplayMath(`\\iint_{[0,1]\\times[0,1]} xy\\,dA`),
                s: withDisplayMath(`\\frac{1}{4}`),
                tag: "Fubini"
              };
            case 3:
              return {
                q: withDisplayMath(`\\iint_{D} 1\\,dA,\\quad D=\\{(x,y):x^2+y^2\\le 1\\}`),
                s: withDisplayMath(`\\pi`),
                tag: "Area of disk"
              };
            case 4:
              return {
                q: withDisplayMath(`\\iint_{D} (x^2+y^2)\\,dA,\\quad D=\\{(x,y):x^2+y^2\\le 1\\}`),
                s: withDisplayMath(`\\frac{\\pi}{2}`),
                tag: "Polar coordinates"
              };
            case 5:
              return {
                q: withDisplayMath(`\\int_0^1\\int_0^x (x+y)\\,dy\\,dx`),
                s: withDisplayMath(`\\frac{1}{2}`),
                tag: "Triangular region"
              };
            case 6:
              return {
                q: withDisplayMath(`\\iint_{[0,1]^2} e^{x+y}\\,dA`),
                s: withDisplayMath(`(e-1)^2`),
                tag: "Separable integrand"
              };
            case 7:
              return {
                q: withDisplayMath(`\\iint_{[0,2]\\times[0,1]} x^2\\,dA`),
                s: withDisplayMath(`\\frac{8}{3}`),
                tag: "Iterated integral"
              };
            default:
              return {
                q: withDisplayMath(`\\iint_{[0,1]^2} (x^2+y^2)\\,dA`),
                s: withDisplayMath(`\\frac{2}{3}`),
                tag: "Polynomial"
              };
          }
        }, 120);
      }

if (level === "hard") {
        return buildPool(() => {
          const a = randInt(1, 3);
          const type = randInt(1, 10);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\iint_D (x^2+y^2)\\,dA,\\quad D=\\{(x,y):1\\le x^2+y^2\\le 4\\}`),
                s: withDisplayMath(`\\frac{15\\pi}{2}`),
                tag: "Polar coordinates"
              };
            case 2:
              return {
                q: withDisplayMath(`\\iint_D xy\\,dA,\\quad D=\\{(x,y):0\\le y\\le x\\le 1\\}`),
                s: withDisplayMath(`\\frac{1}{8}`),
                tag: "Non-rectangular region"
              };
            case 3:
              return {
                q: withDisplayMath(`\\iint_D (x+y)\\,dA,\\quad D=\\{(x,y):0\\le x\\le 1,\\ x\\le y\\le 1\\}`),
                s: withDisplayMath(`\\frac{2}{3}`),
                tag: "Region description"
              };
            case 4:
              return {
                q: withDisplayMath(`\\iint_D e^{x^2+y^2}\\,dA,\\quad D=\\{(x,y):x^2+y^2\\le 1\\}`),
                s: withDisplayMath(`\\pi(e-1)`),
                tag: "Polar substitution"
              };
            case 5:
              return {
                q: withDisplayMath(`\\iiint_{[0,1]^3} (x+y+z)\\,dV`),
                s: withDisplayMath(`\\frac{3}{2}`),
                tag: "Triple integral"
              };
            case 6:
              return {
                q: withDisplayMath(`\\iiint_{[0,${a}]^3} 1\\,dV`),
                s: withDisplayMath(`${a ** 3}`),
                tag: "Volume"
              };
            case 7:
              return {
                q: withDisplayMath(`\\iint_D \\frac{1}{1+x^2+y^2}\\,dA,\\quad D=\\{(x,y):x^2+y^2\\le 1\\}`),
                s: withDisplayMath(`\\pi\\ln 2`),
                tag: "Polar coordinates"
              };
            case 8:
              return {
                q: withDisplayMath(`\\int_0^1 \\int_{x^2}^{x} 1\\,dy\\,dx`),
                s: withDisplayMath(`\\frac{1}{6}`),
                tag: "Curved bounds"
              };
            case 9:
              return {
                q: withDisplayMath(`\\iint_D (x^2-y^2)\\,dA,\\quad D=\\{(x,y):x^2+y^2\\le 1\\}`),
                s: withDisplayMath(`0`),
                tag: "Symmetry"
              };
            default:
              return {
                q: withDisplayMath(`\\iiint_{[0,1]^3} xyz\\,dV`),
                s: withDisplayMath(`\\frac{1}{8}`),
                tag: "Product integral"
              };
          }
        }, 120);
      }

return buildPool(() => {
        const a = randInt(1, 3);
        const b = randInt(1, 3);
        const type = randInt(1, 10);

switch (type) {
          case 1:
            return {
              q: withDisplayMath(`\\iint_{[0,${a}]\\times[0,${b}]} (x+y)\\,dA`),
              s: withDisplayMath(`\\frac{${a * a * b}}{2}+\\frac{${a * b * b}}{2}`),
              tag: "Rectangular region"
            };
          case 2:
            return {
              q: withDisplayMath(`\\iint_D 1\\,dA,\\quad D=\\{(x,y):x^2+y^2\\le 1\\}`),
              s: withDisplayMath(`\\pi`),
              tag: "Area of disk"
            };
          case 3:
            return {
              q: withDisplayMath(`\\iint_D (x^2+y^2)\\,dA,\\quad D=\\{(x,y):x^2+y^2\\le 1\\}`),
              s: withDisplayMath(`\\frac{\\pi}{2}`),
              tag: "Polar coordinates"
            };
          case 4:
            return {
              q: withDisplayMath(`\\int_0^1\\int_0^x (x+y)\\,dy\\,dx`),
              s: withDisplayMath(`\\frac{1}{2}`),
              tag: "Triangular region"
            };
          case 5:
            return {
              q: withDisplayMath(`\\iint_{[0,1]^2} e^{x+y}\\,dA`),
              s: withDisplayMath(`(e-1)^2`),
              tag: "Separable integrand"
            };
          case 6:
            return {
              q: withDisplayMath(`\\iint_D xy\\,dA,\\quad D=\\{(x,y):0\\le y\\le x\\le 1\\}`),
              s: withDisplayMath(`\\frac{1}{8}`),
              tag: "Non-rectangular region"
            };
          case 7:
            return {
              q: withDisplayMath(`\\iiint_{[0,1]^3} (x+y+z)\\,dV`),
              s: withDisplayMath(`\\frac{3}{2}`),
              tag: "Triple integral"
            };
          case 8:
            return {
              q: withDisplayMath(`\\iiint_{[0,1]^3} xyz\\,dV`),
              s: withDisplayMath(`\\frac{1}{8}`),
              tag: "Product integral"
            };
          case 9:
            return {
              q: withDisplayMath(`\\int_0^1 \\int_{x^2}^{x} 1\\,dy\\,dx`),
              s: withDisplayMath(`\\frac{1}{6}`),
              tag: "Curved bounds"
            };
          default:
            return {
              q: withDisplayMath(`\\iint_D (x^2-y^2)\\,dA,\\quad D=\\{(x,y):x^2+y^2\\le 1\\}`),
              s: withDisplayMath(`0`),
              tag: "Symmetry"
            };
          }
      }, 120);
    }

function directionalDerivativeTemplates(level = "medium") {
      if (level === "easy") {
        return buildPool(() => {
          const a = randInt(1, 4);
          const b = randInt(1, 4);
          const c = randInt(1, 3);
          const type = randInt(1, 12);

switch (type) {
            case 1:
              return {
                q: withDisplayMath(`f(x,y)=x^2+y^2,\\quad D_{\\mathbf{u}}f(1,1),\\quad \\mathbf{u}=\\left(\\frac{1}{\\sqrt{2}},\\frac{1}{\\sqrt{2}}\\right)`),
                s: withDisplayMath(`\\nabla f(1,1)=(2,2),\\quad D_{\\mathbf{u}}f(1,1)=2\\sqrt{2}`),
                tag: "Gradient method"
              };
            case 2:
              return {
                q: withDisplayMath(`f(x,y)=x^2y+3y,\\quad D_{\\mathbf{u}}f(1,2),\\quad \\mathbf{u}=\\left(1,0\\right)`),
                s: withDisplayMath(`\\nabla f(x,y)=(2xy,x^2+3),\\quad \\nabla f(1,2)=(4,4),\\quad D_{\\mathbf{u}}f(1,2)=4`),
                tag: "Partial derivative direction"
              };
            case 3:
              return {
                q: withDisplayMath(`f(x,y)=e^{x+y},\\quad D_{\\mathbf{u}}f(0,0),\\quad \\mathbf{u}=\\left(\\frac{1}{\\sqrt{2}},-\\frac{1}{\\sqrt{2}}\\right)`),
                s: withDisplayMath(`\\nabla f(0,0)=(1,1),\\quad D_{\\mathbf{u}}f(0,0)=0`),
                tag: "Orthogonal direction"
              };
            case 4:
              return {
                q: withDisplayMath(`f(x,y)=x^2+xy+y^2,\\quad D_{\\mathbf{u}}f(1,0),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{5}}(1,2)`),
                s: withDisplayMath(`\\nabla f(x,y)=(2x+y,x+2y),\\quad \\nabla f(1,0)=(2,1),\\quad D_{\\mathbf{u}}f(1,0)=\\frac{4}{\\sqrt{5}}`),
                tag: "Normalized vector"
              };
            case 5:
              return {
                q: withDisplayMath(`f(x,y,z)=x^2+y^2+z^2,\\quad D_{\\mathbf{u}}f(1,1,1),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{3}}(1,1,1)`),
                s: withDisplayMath(`\\nabla f(1,1,1)=(2,2,2),\\quad D_{\\mathbf{u}}f(1,1,1)=2\\sqrt{3}`),
                tag: "Three variables"
              };
            case 6:
              return {
                q: withDisplayMath(`f(x,y)=\\ln(1+x^2+y^2),\\quad D_{\\mathbf{u}}f(1,0),\\quad \\mathbf{u}=(0,1)`),
                s: withDisplayMath(`\\nabla f(x,y)=\\left(\\frac{2x}{1+x^2+y^2},\\frac{2y}{1+x^2+y^2}\\right),\\quad D_{\\mathbf{u}}f(1,0)=0`),
                tag: "Zero directional derivative"
              };
            case 7:
              return {
                q: withDisplayMath(`f(x,y)=x e^y,\\quad D_{\\mathbf{u}}f(1,0),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{2}}(1,1)`),
                s: withDisplayMath(`\\nabla f(x,y)=(e^y,xe^y),\\quad \\nabla f(1,0)=(1,1),\\quad D_{\\mathbf{u}}f(1,0)=\\sqrt{2}`),
                tag: "Gradient method"
              };
            case 8:
              return {
                q: withDisplayMath(`f(x,y)=x^3-y^2,\\quad D_{\\mathbf{u}}f(1,1),\\quad \\mathbf{u}=\\left(0,1\\right)`),
                s: withDisplayMath(`\\nabla f(x,y)=(3x^2,-2y),\\quad \\nabla f(1,1)=(3,-2),\\quad D_{\\mathbf{u}}f(1,1)=-2`),
                tag: "Coordinate direction"
              };
            case 9:
              return {
                q: withDisplayMath(`f(x,y)=x^2+y^2,\\quad \\text{find the direction of maximum increase at }(1,2)`),
                s: withDisplayMath(`\\nabla f(1,2)=(2,4),\\quad \\mathbf{u}_{\\max}=\\frac{1}{\\sqrt{5}}(1,2)`),
                tag: "Maximum increase"
              };
            case 10:
              return {
                q: withDisplayMath(`f(x,y)=x^2-xy,\\quad D_{\\mathbf{u}}f(1,1),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{2}}(1,-1)`),
                s: withDisplayMath(`\\nabla f(x,y)=(2x-y,-x),\\quad \\nabla f(1,1)=(1,-1),\\quad D_{\\mathbf{u}}f(1,1)=\\sqrt{2}`),
                tag: "Gradient method"
              };
            case 11:
              return {
                q: withDisplayMath(`f(x,y)=\\sqrt{1+x^2+y^2},\\quad D_{\\mathbf{u}}f(0,1),\\quad \\mathbf{u}=(1,0)`),
                s: withDisplayMath(`\\nabla f(x,y)=\\left(\\frac{x}{\\sqrt{1+x^2+y^2}},\\frac{y}{\\sqrt{1+x^2+y^2}}\\right),\\quad D_{\\mathbf{u}}f(0,1)=0`),
                tag: "Gradient method"
              };
            default:
              return {
                q: withDisplayMath(`f(x,y)=x^2+${a}xy+${b}y^2,\\quad D_{\\mathbf{u}}f(1,1),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{2}}(1,1)`),
                s: withDisplayMath(`\\nabla f(x,y)=(2x+${a}y,${a}x+${2*b}y),\\quad \\nabla f(1,1)=(${2+a},${a+2*b}),\\quad D_{\\mathbf{u}}f(1,1)=\\frac{${2+a}+${a+2*b}}{\\sqrt{2}}`),
                tag: "Parameterized"
              };
          }
        }, 120);
      }

const commonPool = buildPool(() => {
        const a = randInt(1, 4);
        const b = randInt(1, 4);
        const c = randInt(1, 3);
        const type = randInt(1, 12);

switch (type) {
          case 1:
            return {
              q: withDisplayMath(`f(x,y)=x^2+y^2,\\quad D_{\\mathbf{u}}f(1,1),\\quad \\mathbf{u}=\\left(\\frac{1}{\\sqrt{2}},\\frac{1}{\\sqrt{2}}\\right)`),
              s: withDisplayMath(`\\nabla f(1,1)=(2,2),\\quad D_{\\mathbf{u}}f(1,1)=2\\sqrt{2}`),
              tag: "Gradient method"
            };
          case 2:
            return {
              q: withDisplayMath(`f(x,y)=x^2y+3y,\\quad D_{\\mathbf{u}}f(1,2),\\quad \\mathbf{u}=\\left(1,0\\right)`),
              s: withDisplayMath(`\\nabla f(x,y)=(2xy,x^2+3),\\quad \\nabla f(1,2)=(4,4),\\quad D_{\\mathbf{u}}f(1,2)=4`),
              tag: "Partial derivative direction"
            };
          case 3:
            return {
              q: withDisplayMath(`f(x,y)=e^{x+y},\\quad D_{\\mathbf{u}}f(0,0),\\quad \\mathbf{u}=\\left(\\frac{1}{\\sqrt{2}},-\\frac{1}{\\sqrt{2}}\\right)`),
              s: withDisplayMath(`\\nabla f(0,0)=(1,1),\\quad D_{\\mathbf{u}}f(0,0)=0`),
              tag: "Orthogonal direction"
            };
          case 4:
            return {
              q: withDisplayMath(`f(x,y)=x^2+xy+y^2,\\quad D_{\\mathbf{u}}f(1,0),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{5}}(1,2)`),
              s: withDisplayMath(`\\nabla f(x,y)=(2x+y,x+2y),\\quad \\nabla f(1,0)=(2,1),\\quad D_{\\mathbf{u}}f(1,0)=\\frac{4}{\\sqrt{5}}`),
              tag: "Normalized vector"
            };
          case 5:
            return {
              q: withDisplayMath(`f(x,y,z)=x^2+y^2+z^2,\\quad D_{\\mathbf{u}}f(1,1,1),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{3}}(1,1,1)`),
              s: withDisplayMath(`\\nabla f(1,1,1)=(2,2,2),\\quad D_{\\mathbf{u}}f(1,1,1)=2\\sqrt{3}`),
              tag: "Three variables"
            };
          case 6:
            return {
              q: withDisplayMath(`f(x,y)=\\ln(1+x^2+y^2),\\quad D_{\\mathbf{u}}f(1,0),\\quad \\mathbf{u}=(0,1)`),
              s: withDisplayMath(`\\nabla f(x,y)=\\left(\\frac{2x}{1+x^2+y^2},\\frac{2y}{1+x^2+y^2}\\right),\\quad D_{\\mathbf{u}}f(1,0)=0`),
              tag: "Zero directional derivative"
            };
          case 7:
            return {
              q: withDisplayMath(`f(x,y)=x e^y,\\quad D_{\\mathbf{u}}f(1,0),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{2}}(1,1)`),
              s: withDisplayMath(`\\nabla f(x,y)=(e^y,xe^y),\\quad \\nabla f(1,0)=(1,1),\\quad D_{\\mathbf{u}}f(1,0)=\\sqrt{2}`),
              tag: "Gradient method"
            };
          case 8:
            return {
              q: withDisplayMath(`f(x,y)=x^3-y^2,\\quad D_{\\mathbf{u}}f(1,1),\\quad \\mathbf{u}=\\left(0,1\\right)`),
              s: withDisplayMath(`\\nabla f(x,y)=(3x^2,-2y),\\quad \\nabla f(1,1)=(3,-2),\\quad D_{\\mathbf{u}}f(1,1)=-2`),
              tag: "Coordinate direction"
            };
          case 9:
            return {
              q: withDisplayMath(`f(x,y)=x^2+y^2,\\quad \\text{find the direction of maximum increase at }(1,2)`),
              s: withDisplayMath(`\\nabla f(1,2)=(2,4),\\quad \\mathbf{u}_{\\max}=\\frac{1}{\\sqrt{5}}(1,2)`),
              tag: "Maximum increase"
            };
          case 10:
            return {
              q: withDisplayMath(`f(x,y)=x^2-xy,\\quad D_{\\mathbf{u}}f(1,1),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{2}}(1,-1)`),
              s: withDisplayMath(`\\nabla f(x,y)=(2x-y,-x),\\quad \\nabla f(1,1)=(1,-1),\\quad D_{\\mathbf{u}}f(1,1)=\\sqrt{2}`),
              tag: "Gradient method"
            };
          case 11:
            return {
              q: withDisplayMath(`f(x,y)=\\sqrt{1+x^2+y^2},\\quad D_{\\mathbf{u}}f(0,1),\\quad \\mathbf{u}=(1,0)`),
              s: withDisplayMath(`\\nabla f(x,y)=\\left(\\frac{x}{\\sqrt{1+x^2+y^2}},\\frac{y}{\\sqrt{1+x^2+y^2}}\\right),\\quad D_{\\mathbf{u}}f(0,1)=0`),
              tag: "Gradient method"
            };
          default:
            return {
              q: withDisplayMath(`f(x,y)=x^2+${a}xy+${b}y^2,\\quad D_{\\mathbf{u}}f(1,1),\\quad \\mathbf{u}=\\frac{1}{\\sqrt{2}}(1,1)`),
              s: withDisplayMath(`\\nabla f(x,y)=(2x+${a}y,${a}x+${2*b}y),\\quad \\nabla f(1,1)=(${2+a},${a+2*b}),\\quad D_{\\mathbf{u}}f(1,1)=\\frac{${2+a}+${a+2*b}}{\\sqrt{2}}`),
              tag: "Parameterized"
            };
        }
      }, 120);

if (level === "easy") {
        return commonPool.filter((_, index) => index % 2 === 0);
      }
      if (level === "hard") {
        return commonPool;
      }
      return commonPool.slice(0, 90);
    }

if (level === "hard") {
        return buildPool(() => {
          const type = randInt(1, 10);
          switch (type) {
            case 1:
              return {
                q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{x^2y}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Study continuity, partial derivatives, and differentiability at }(0,0).`),
                s: withDisplayMath(`f\\text{ is continuous at }(0,0),\\ \\partial_x f(0,0)=0,\\ \\partial_y f(0,0)=0,\\text{ and }f\\text{ is differentiable at }(0,0).`),
                tag: "Full point analysis"
              };
            case 2:
              return {
                q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{xy}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Study continuity and differentiability at }(0,0).`),
                s: withDisplayMath(`f\\text{ is not continuous at }(0,0),\\text{ hence it is not differentiable there.}`),
                tag: "Path dependence"
              };
            case 3:
              return {
                q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{x^3}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
                s: withDisplayMath(`\\partial_x f(0,0)=1,\\ \\partial_y f(0,0)=0,\\text{ but }f\\text{ is not differentiable at }(0,0).`),
                tag: "Partials not sufficient"
              };
            case 4:
              return {
                q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{x^2y^2}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
                s: withDisplayMath(`\\text{Yes. }|f(x,y)|\\le x^2+y^2,\\text{ so }f=o(\\sqrt{x^2+y^2}).`),
                tag: "Estimate"
              };
            case 5:
              return {
                q: withDisplayMath(`f(x,y)=|x|y.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
                s: withDisplayMath(`\\text{No. The increment ratio depends on the sign of }x.`),
                tag: "Absolute value"
              };
            case 6:
              return {
                q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{x^4+y^4}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
                s: withDisplayMath(`\\text{Yes. }f(x,y)=O(x^2+y^2),\\text{ so }f=o(\\sqrt{x^2+y^2}).`),
                tag: "Higher order"
              };
            case 7:
              return {
                q: withDisplayMath(`f(x,y)=\\sqrt{|xy|}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
                s: withDisplayMath(`\\text{No. Along }x=y=t,\\ f(t,t)=|t|,\\text{ which is not }o(\\sqrt{2}|t|).`),
                tag: "Counterexample path"
              };
            case 8:
              return {
                q: withDisplayMath(`f(x,y)=x^2\\sin\\!\\left(\\frac{1}{x}\\right)+y^2\\quad (x\\ne 0),\\text{ suitably extended at }x=0.\\ \\text{Is }f\\text{ differentiable at }(0,0)?`),
                s: withDisplayMath(`\\text{Yes, with a suitable extension }f(0,y)=y^2,\\text{ because }x^2\\sin(1/x)=o(\\sqrt{x^2+y^2}).`),
                tag: "Oscillatory term"
              };
            case 9:
              return {
                q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{x^2y}{\\sqrt{x^2+y^2}},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
                s: withDisplayMath(`\\text{Yes. Since }|f(x,y)|\\le (x^2+y^2),\\text{ the function is differentiable at }(0,0).`),
                tag: "Estimate"
              };
            default:
              return {
                q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{xy^2}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
                s: withDisplayMath(`\\text{Yes. }|f(x,y)|\\le |x|\\,|y|\\le \\frac{x^2+y^2}{2},\\text{ hence }f=o(\\sqrt{x^2+y^2}).`),
                tag: "Estimate"
              };
          }
        }, 120);
      }

return buildPool(() => {
        const type = randInt(1, 10);
        switch (type) {
          case 1:
            return {
              q: withDisplayMath(`f(x,y)=x^2+y^2.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{Yes. Polynomials are differentiable everywhere.}`),
              tag: "Polynomial"
            };
          case 2:
            return {
              q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{x^2y}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{Yes. }f=o(\\sqrt{x^2+y^2}),\\text{ so }f\\text{ is differentiable at }(0,0).`),
              tag: "Little-o test"
            };
          case 3:
            return {
              q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{xy}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{No. The function is not continuous at }(0,0).`),
              tag: "Path dependence"
            };
          case 4:
            return {
              q: withDisplayMath(`f(x,y)=|x|+|y|.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{No. There is no linear approximation at }(0,0).`),
              tag: "Absolute value"
            };
          case 5:
            return {
              q: withDisplayMath(`f(x,y)=e^{x+y}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{Yes. Smooth functions are differentiable everywhere.}`),
              tag: "Smooth function"
            };
          case 6:
            return {
              q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{x^2y^2}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{Yes. }|f(x,y)|\\le x^2+y^2.`),
              tag: "Estimate"
            };
          case 7:
            return {
              q: withDisplayMath(`f(x,y)=\\max\\{x,y\\}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{No. The behavior is not linear across }x=y.`),
              tag: "Non-smooth"
            };
          case 8:
            return {
              q: withDisplayMath(`f(x,y)=\\sqrt{1+x^2+y^2}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{Yes.}`),
              tag: "Composition"
            };
          case 9:
            return {
              q: withDisplayMath(`f(x,y)=\\begin{cases}\\frac{x^3}{x^2+y^2},&(x,y)\\ne(0,0)\\\\0,&(x,y)=(0,0)\\end{cases}.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{No.}`),
              tag: "Partials not sufficient"
            };
          default:
            return {
              q: withDisplayMath(`f(x,y)=x^2\\sin y+y^2\\cos x.\\quad \\text{Is }f\\text{ differentiable at }(0,0)?`),
              s: withDisplayMath(`\\text{Yes. It is smooth near }(0,0).`),
              tag: "Smooth function"
            };
          }
      }, 120);
    }

function generatorForTopic(topic, level) {
      switch (topic) {
        case "multivariable-limits": return multivariableLimitTemplates(level);
        case "multiple-integrals": return multipleIntegralTemplates(level);
        case "directional-derivatives": return directionalDerivativeTemplates(level);
        case "differentiability": return differentiabilityTemplates(level);
        default: return [];
      }
    }

function buildExercises(topic, count, level) {
      const pool = generatorForTopic(topic, level);
      return sampleExercises(pool, count);
    }

let currentTopic = "multivariable-limits";
    let solutionsVisible = false;
    let currentExercises = [];

function labelForTopic(topic) {
      switch (topic) {
        case "multivariable-limits": return "Multivariable Limits";
        case "multiple-integrals": return "Multiple Integrals";
        case "directional-derivatives": return "Directional Derivatives";
        case "differentiability": return "Differentiability";
        case "exam": return "Exam Mode";
        default: return "Worksheet";
      }
    }

function defaultTitleForTopic(topic) {
      switch (topic) {
        case "multivariable-limits": return "Multivariable Limits Worksheet";
        case "multiple-integrals": return "Multiple Integrals Worksheet";
        case "directional-derivatives": return "Directional Derivatives Worksheet";
        case "differentiability": return "Differentiability Worksheet";
        case "exam": return "Calculus II Exam Practice";
        default: return "Calculus II Worksheet";
      }
    }

function updateTopicButtons() {
      document.querySelectorAll("#topicNav button").forEach((btn) => {
        btn.classList.toggle("active", btn.dataset.topic === currentTopic);
      });
    }

async function typesetMath(elements) {
      if (window.MathJax && window.MathJax.typesetPromise) {
        await window.MathJax.typesetPromise(elements);
      }
    }

exerciseList.innerHTML = "";
      solutionList.innerHTML = "";

currentExercises.forEach((ex) => {
        const tag = ex.examTopic ? labelForTopic(ex.examTopic).toUpperCase() : ex.tag;

solutionsCard.classList.toggle("hidden", !solutionsVisible);
      updatePills();
      await typesetMath([exerciseList, solutionList]);
    }

const count = Math.max(1, Math.min(50, Number(countInput.value) || 10));
      countInput.value = count;

const level = levelSelect.value;
      const title = titleInput.value.trim() || defaultTitleForTopic(currentTopic);
      previewTitle.textContent = title;

currentExercises = currentTopic === "exam"
        ? buildExamSheet(level)
        : buildExercises(currentTopic, count, level);

await renderLists();

status.textContent = currentTopic === "exam"
        ? `Generated ${currentExercises.length} exam exercises.`
        : `Generated ${currentExercises.length} exercises.`;
    }

async function setTopic(topic) {
      currentTopic = topic;
      const titleInput = document.getElementById("title");
      const countWrap = document.getElementById("countWrap");
      const status = document.getElementById("status");

titleInput.value = defaultTitleForTopic(topic);
      countWrap.classList.toggle("hidden", topic === "exam");
      updateTopicButtons();
      solutionsVisible = false;
      document.getElementById("toggleSolutionsBtn").textContent = "Show solutions";
      status.textContent = "Ready.";

await generateWorksheet();
    }

try {
        status.textContent = "Preparing PDF...";
        pdfArea.innerHTML = buildPdfMarkup();
        await typesetMath([pdfArea]);

for (let i = 0; i < pages.length; i++) {
          const canvas = await html2canvas(pages[i], {
            scale: 2,
            useCORS: true,
            backgroundColor: "#ffffff"
          });

const imgData = canvas.toDataURL("image/png");
          const imgWidth = pageWidth;
          const imgHeight = (canvas.height * imgWidth) / canvas.width;

if (i > 0) pdf.addPage();
          pdf.addImage(imgData, "PNG", 0, 0, imgWidth, Math.min(imgHeight, pageHeight));
        }

const safeName = title
          .toLowerCase()
          .replace(/[^a-z0-9]+/g, "-")
          .replace(/^-+|-+$/g, "") || "worksheet";

document.getElementById("generateBtn").addEventListener("click", generateWorksheet);

document.getElementById("toggleSolutionsBtn").addEventListener("click", async () => {
      solutionsVisible = !solutionsVisible;
      document.getElementById("toggleSolutionsBtn").textContent = solutionsVisible ? "Hide solutions" : "Show solutions";
      await renderLists();
    });

document.querySelectorAll("#topicNav button").forEach((btn) => {
      btn.addEventListener("click", () => setTopic(btn.dataset.topic));
    });

setTopic("multivariable-limits");
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Geometry and Linear Algebra Generator</title>
  <meta name="description" content="University-style Geometry and Linear Algebra worksheet generator with systems, determinants, vector spaces, linear maps, eigenvalues, orthogonality, quadratic forms, and exam mode." />

* { box-sizing: border-box; }

body {
      margin: 0;
      font-family: Inter, Arial, sans-serif;
      color: var(--text);
      background:
        radial-gradient(circle at top left, rgba(114,161,255,0.20), transparent 28%),
        radial-gradient(circle at top right, rgba(143,118,255,0.16), transparent 30%),
        linear-gradient(180deg, var(--bg-1) 0%, var(--bg-2) 100%);
      min-height: 100vh;
    }

.wrap { max-width: 1280px; margin: 0 auto; padding: 28px; }

.hero {
      display: grid;
      grid-template-columns: 88px 1fr;
      gap: 18px;
      align-items: center;
      margin-bottom: 24px;
    }

.hero h1 {
      margin: 0 0 10px;
      font-size: clamp(2rem, 4.5vw, 3.5rem);
      line-height: 1.02;
      letter-spacing: -0.03em;
    }

.hero p {
      margin: 0;
      color: var(--muted);
      line-height: 1.75;
      max-width: 980px;
      font-size: 1.03rem;
    }

.topic-nav {
      display: flex;
      gap: 10px;
      flex-wrap: wrap;
      margin: 20px 0 28px;
    }

.topic-nav button {
      width: auto;
      padding: 11px 16px;
      border-radius: 999px;
      border: 1px solid var(--border);
      background: rgba(255,255,255,0.04);
      color: var(--muted);
      cursor: pointer;
      font-weight: 700;
      transition: 0.2s ease;
    }

.topic-nav button:hover { transform: translateY(-1px); color: var(--text); }

.topic-nav button.active {
      background: linear-gradient(135deg, var(--accent), var(--accent-2));
      color: white;
      border: none;
      box-shadow: 0 14px 30px rgba(114,161,255,0.22);
    }

.grid {
      display: grid;
      grid-template-columns: 360px 1fr;
      gap: 24px;
      align-items: start;
    }

.settings-card { position: sticky; top: 18px; }
    .stack > * + * { margin-top: 16px; }

.card h2 { margin: 0 0 6px; font-size: 1.2rem; }

.subtle, .status {
      color: var(--muted);
      line-height: 1.6;
      font-size: 0.95rem;
    }

label {
      display: block;
      margin-bottom: 8px;
      color: var(--muted);
      font-size: 0.95rem;
      font-weight: 600;
    }

input:focus, select:focus {
      border-color: rgba(114,161,255,0.65);
      box-shadow: 0 0 0 4px rgba(114,161,255,0.12);
    }

button { cursor: pointer; font-weight: 800; transition: 0.2s ease; }
    button:hover { transform: translateY(-1px); }

.primary {
      background: linear-gradient(135deg, var(--accent), var(--accent-2));
      border: none;
      box-shadow: 0 14px 28px rgba(114,161,255,0.25);
    }

.secondary { background: rgba(255,255,255,0.06); }

.preview-title-row {
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 12px;
      flex-wrap: wrap;
      margin-bottom: 14px;
    }

.exercise {
      border: 1px solid var(--border);
      border-radius: 18px;
      padding: 16px;
      margin-top: 14px;
      background: rgba(255,255,255,0.03);
    }

.exercise-head {
      display: flex;
      gap: 10px;
      justify-content: space-between;
      align-items: center;
      flex-wrap: wrap;
      margin-bottom: 10px;
    }

.exercise-number {
      color: var(--muted);
      font-weight: 700;
      font-size: 0.95rem;
    }

.math { font-size: 1.08rem; line-height: 1.75; overflow-wrap: anywhere; }
    .solutions-card.hidden, .hidden { display: none !important; }

.footer-copy {
      margin-top: 28px;
      color: var(--muted);
      line-height: 1.7;
      font-size: 0.95rem;
    }

#pdfArea {
      position: absolute;
      left: -99999px;
      top: 0;
      width: 794px;
      background: white;
      color: black;
      padding: 40px;
    }

.pdf-page {
      width: 100%;
      min-height: 1040px;
      padding: 10px 0 30px;
      background: white;
      color: black;
      page-break-after: always;
    }

.pdf-page:last-child { page-break-after: auto; }
    .pdf-title { font-size: 28px; font-weight: 700; margin-bottom: 6px; color: black; }
    .pdf-meta { font-size: 14px; color: #333; margin-bottom: 22px; }
    .pdf-section-title { font-size: 20px; font-weight: 700; margin: 10px 0 18px; color: black; }
    .pdf-exercise {
      border: 1px solid #d6d6d6;
      border-radius: 12px;
      padding: 12px 14px;
      margin-bottom: 12px;
      background: #fff;
      break-inside: avoid;
    }

.pdf-head {
      display: flex;
      justify-content: space-between;
      align-items: center;
      gap: 10px;
      margin-bottom: 8px;
      flex-wrap: wrap;
    }

.pdf-num { color: #444; font-weight: 700; font-size: 13px; }
    .pdf-math { color: black; font-size: 16px; line-height: 1.6; }

@media (max-width: 980px) {
      .hero { grid-template-columns: 1fr; }
      .hero-badge { width: 72px; height: 72px; font-size: 28px; }
      .grid { grid-template-columns: 1fr; }
      .settings-card { position: static; }
    }
  </style>
</head>
<body>
  <div class="wrap">
    <section class="hero">
      <div class="hero-badge">A</div>
      <div>
        <h1>Geometry and Linear Algebra Generator</h1>
        <p>
          Generate university-style worksheets inspired by first-year Geometry and Linear Algebra courses:
          linear systems, matrices and determinants, vector spaces and linear maps, eigenvalues and diagonalization,
          orthogonality and quadratic forms, plus mixed exam-mode practice. All exercises and solutions are rendered in LaTeX.
        </p>
      </div>
    </section>

<div class="topic-nav" id="topicNav">
      <button data-topic="systems" class="active">Linear Systems</button>
      <button data-topic="matrices">Matrices & Determinants</button>
      <button data-topic="vector-spaces">Vector Spaces & Linear Maps</button>
      <button data-topic="eigen">Eigenvalues & Diagonalization</button>
      <button data-topic="orthogonality">Orthogonality & Quadratic Forms</button>
      <button data-topic="exam">Exam Mode</button>
    </div>

<div class="grid">
      <div class="card settings-card stack">
        <div>
          <h2>Settings</h2>
          <div class="subtle">Choose a topic, difficulty, and generate a fresh GAL-style worksheet instantly.</div>
        </div>

<div>
          <label for="title">Worksheet title</label>
          <input id="title" value="Geometry and Linear Algebra Worksheet" />
        </div>

<div id="countWrap">
          <label for="count">Number of exercises</label>
          <input id="count" type="number" min="1" max="50" value="10" />
        </div>

<div class="status" id="status">Ready.</div>
      </div>

<div>
        <div class="card">
          <div class="preview-title-row">
            <h2 id="previewTitle" style="margin:0;">Geometry and Linear Algebra Worksheet</h2>
            <div class="level-pill" id="levelPill">MEDIUM</div>
          </div>
          <div id="exerciseList"></div>
        </div>

<div class="card solutions-card hidden" id="solutionsCard" style="margin-top:24px;">
          <div class="preview-title-row">
            <h2 style="margin:0;">Solutions</h2>
            <div class="level-pill" id="solutionsPill">HIDDEN</div>
          </div>
          <div id="solutionList"></div>
        </div>
      </div>
    </div>

<div class="footer-copy">
      In Exam Mode, the generator creates one exercise for each macro-topic:
      systems, determinants, vector spaces/linear maps, eigenvalues, and orthogonality/quadratic forms.
    </div>
  </div>

const choice = (arr) => {
      if (!Array.isArray(arr) || arr.length === 0) throw new Error("Cannot choose from an empty array.");
      return arr[Math.floor(Math.random() * arr.length)];
    };

function gcd(a, b) {
      a = Math.abs(a); b = Math.abs(b);
      while (b !== 0) { const t = b; b = a % b; a = t; }
      return a;
    }

function withDisplayMath(latex) { return `\\[${latex}\\]`; }

if (level === "hard") {
        return buildPool(() => {
          const type = randInt(1,10);
          switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\text{For which }\\lambda\\in\\mathbb{R}\\text{ does }\\begin{cases}x+y+z=1\\\\x+2y+3z=\\lambda\\\\2x+3y+4z=\\lambda+1\\end{cases}\\text{ have solutions?}`),
                s: withDisplayMath(`\\text{The system is compatible for every }\\lambda,\\text{ with a unique solution.}`),
                tag: "Parameter study"
              };
            case 2:
              return {
                q: withDisplayMath(`\\text{For which }k\\text{ is }\\begin{cases}x+y+z=1\\\\x+2y+3z=2\\\\2x+3y+(k+2)z=3\\end{cases}\\text{ compatible?}`),
                s: withDisplayMath(`\\det A = k-1.\\ \\text{Unique solution if }k\\neq 1;\\ \\text{if }k=1\\text{ the system is compatible with infinitely many solutions.}`),
                tag: "Rouché-Capelli"
              };
            case 3:
              return {
                q: withDisplayMath(`\\text{Compute a basis of }\\ker A\\text{ for }A=\\begin{pmatrix}1&2&1&0\\\\0&1&1&1\\\\1&3&2&1\\end{pmatrix}`),
                s: withDisplayMath(`\\ker A=\\operatorname{span}\\{(-1,-1,1,0),(2,-1,0,1)\\}`),
                tag: "Kernel basis"
              };
            case 4:
              return {
                q: withDisplayMath(`\\text{Solve }AX=b\\text{ with }A=\\begin{pmatrix}1&1&1\\\\1&2&3\\\\1&3&6\\end{pmatrix},\\ b=\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}`),
                s: withDisplayMath(`X=\\begin{pmatrix}1\\\\0\\\\0\\end{pmatrix}`),
                tag: "Triangular elimination"
              };
            case 5:
              return {
                q: withDisplayMath(`\\text{Find the rank of }A=\\begin{pmatrix}1&2&3&4\\\\2&4&6&8\\\\1&1&1&1\\\\0&1&2&3\\end{pmatrix}`),
                s: withDisplayMath(`\\operatorname{rank}(A)=2`),
                tag: "Rank"
              };
            case 6:
              return {
                q: withDisplayMath(`\\text{Discuss the dimension of the solution set of }\\begin{cases}x+y+z+t=0\\\\x+2y+3z+4t=0\\end{cases}`),
                s: withDisplayMath(`\\dim\\mathcal{S}=2`),
                tag: "Homogeneous system"
              };
            case 7:
              return {
                q: withDisplayMath(`\\text{Find a basis of the row space of }A=\\begin{pmatrix}1&2&1\\\\0&1&1\\\\1&3&2\\end{pmatrix}`),
                s: withDisplayMath(`\\text{A basis is }\\{(1,2,1),(0,1,1)\\}`),
                tag: "Row space"
              };
            case 8:
              return {
                q: withDisplayMath(`\\text{Compute }\\dim\\operatorname{Im}A\\text{ and }\\dim\\ker A\\text{ for }A:\\mathbb{R}^4\\to\\mathbb{R}^3,\\ A=\\begin{pmatrix}1&0&1&2\\\\0&1&1&1\\\\1&1&2&3\\end{pmatrix}`),
                s: withDisplayMath(`\\operatorname{rank}(A)=2,\\quad \\dim\\ker A=2`),
                tag: "Rank-nullity"
              };
            case 9:
              return {
                q: withDisplayMath(`\\text{Reduce }A=\\begin{pmatrix}1&2&1\\\\2&4&2\\\\1&1&0\\end{pmatrix}\\text{ to row echelon form.}`),
                s: withDisplayMath(`\\begin{pmatrix}1&2&1\\\\0&1&1\\\\0&0&0\\end{pmatrix}`),
                tag: "Row reduction"
              };
            default:
              return {
                q: withDisplayMath(`\\text{Give all solutions of }\\begin{cases}x+y+z=0\\\\2x+2y+2z=0\\\\x-z=1\\end{cases}`),
                s: withDisplayMath(`(x,y,z)=(1-t,t,-t),\\quad t\\in\\mathbb{R}`),
                tag: "Parametric solution"
              };
          }
        }, 140);
      }

return buildPool(() => {
        const type = randInt(1,10);
        switch (type) {
          case 1:
            return {
              q: withDisplayMath(`\\text{Solve }\\begin{cases}x+y=3\\\\2x-y=0\\end{cases}`),
              s: withDisplayMath(`(x,y)=(1,2)`),
              tag: "2x2 system"
            };
          case 2:
            return {
              q: withDisplayMath(`\\text{Discuss }\\begin{cases}x+y+z=1\\\\2x+2y+2z=2\\\\x-y=0\\end{cases}`),
              s: withDisplayMath(`\\text{Infinitely many solutions: }(x,y,z)=(t,t,1-2t)`),
              tag: "Compatibility"
            };
          case 3:
            return {
              q: withDisplayMath(`\\text{Compute }\\operatorname{rank}\\begin{pmatrix}1&2&3\\\\2&4&6\\\\1&1&1\\end{pmatrix}`),
              s: withDisplayMath(`2`),
              tag: "Rank"
            };
          case 4:
            return {
              q: withDisplayMath(`\\text{Find a basis of }\\ker\\begin{pmatrix}1&1&0\\\\0&1&1\\end{pmatrix}`),
              s: withDisplayMath(`\\ker A=\\operatorname{span}\\{(1,-1,1)\\}`),
              tag: "Kernel"
            };
          case 5:
            return {
              q: withDisplayMath(`\\text{Solve }\\begin{cases}x+2y-z=1\\\\2x-y+z=0\\\\x+y+z=2\\end{cases}`),
              s: withDisplayMath(`(x,y,z)=\\left(\\frac{1}{3},\\frac{2}{3},1\\right)`),
              tag: "Gaussian elimination"
            };
          case 6:
            return {
              q: withDisplayMath(`\\text{Determine }\\dim\\mathcal{S}\\text{ for }\\begin{cases}x+y+z+t=0\\\\x+2y+3z+4t=0\\end{cases}`),
              s: withDisplayMath(`2`),
              tag: "Homogeneous system"
            };
          case 7:
            return {
              q: withDisplayMath(`\\text{Compute }\\dim\\ker A\\text{ for }A=\\begin{pmatrix}1&0&1&2\\\\0&1&1&1\\\\1&1&2&3\\end{pmatrix}`),
              s: withDisplayMath(`2`),
              tag: "Rank-nullity"
            };
          case 8:
            return {
              q: withDisplayMath(`\\text{Is }\\begin{cases}x+y=1\\\\2x+2y=3\\end{cases}\\text{ compatible?}`),
              s: withDisplayMath(`\\text{No}`),
              tag: "Incompatible system"
            };
          case 9:
            return {
              q: withDisplayMath(`\\text{Find a basis of }\\operatorname{Im}A\\text{ for }A=\\begin{pmatrix}1&0&1\\\\0&1&1\\\\1&1&2\\end{pmatrix}`),
              s: withDisplayMath(`\\operatorname{Im}A=\\operatorname{span}\\{(1,0,1),(0,1,1)\\}`),
              tag: "Image"
            };
          default:
            return {
              q: withDisplayMath(`\\text{Give all solutions of }x+y+z=0`),
              s: withDisplayMath(`(x,y,z)=(-s-t,s,t),\\quad s,t\\in\\mathbb{R}`),
              tag: "Parametric form"
            };
          }
      }, 130);
    }

if (level === "hard") {
        return buildPool(() => {
          const type = randInt(1,10);
          switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\det\\begin{pmatrix}1&2&3\\\\0&1&4\\\\5&6&0\\end{pmatrix}`),
                s: withDisplayMath(`1`),
                tag: "3x3 determinant"
              };
            case 2:
              return {
                q: withDisplayMath(`\\text{Find }A^{-1}\\text{ for }A=\\begin{pmatrix}1&1&0\\\\0&1&1\\\\1&0&1\\end{pmatrix}`),
                s: withDisplayMath(`A^{-1}=\\frac{1}{2}\\begin{pmatrix}1&-1&1\\\\1&1&-1\\\\-1&1&1\\end{pmatrix}`),
                tag: "Inverse 3x3"
              };
            case 3:
              return {
                q: withDisplayMath(`\\det\\begin{pmatrix}1&1&1&1\\\\1&2&3&4\\\\1&3&6&10\\\\1&4&10&20\\end{pmatrix}`),
                s: withDisplayMath(`1`),
                tag: "Structured determinant"
              };
            case 4:
              return {
                q: withDisplayMath(`\\text{Find all }k\\text{ such that }A=\\begin{pmatrix}1&k\\\\2&4\\end{pmatrix}\\text{ is invertible.}`),
                s: withDisplayMath(`\\det A = 4-2k,\\quad A\\text{ invertible iff }k\\neq 2`),
                tag: "Parameter"
              };
            case 5:
              return {
                q: withDisplayMath(`\\text{Compute }A^2\\text{ for }A=\\begin{pmatrix}1&1&0\\\\0&1&1\\\\0&0&1\\end{pmatrix}`),
                s: withDisplayMath(`A^2=\\begin{pmatrix}1&2&1\\\\0&1&2\\\\0&0&1\\end{pmatrix}`),
                tag: "Powers"
              };
            case 6:
              return {
                q: withDisplayMath(`\\text{Show whether }AB=BA\\text{ for }A=\\begin{pmatrix}1&1\\\\0&1\\end{pmatrix},\\ B=\\begin{pmatrix}1&0\\\\1&1\\end{pmatrix}`),
                s: withDisplayMath(`AB=\\begin{pmatrix}2&1\\\\1&1\\end{pmatrix},\\quad BA=\\begin{pmatrix}1&1\\\\1&2\\end{pmatrix},\\quad AB\\neq BA`),
                tag: "Non-commutativity"
              };
            case 7:
              return {
                q: withDisplayMath(`\\det\\begin{pmatrix}2&1&0\\\\1&2&1\\\\0&1&2\\end{pmatrix}`),
                s: withDisplayMath(`4`),
                tag: "Tridiagonal determinant"
              };
            case 8:
              return {
                q: withDisplayMath(`\\text{Find }\\chi_A(\\lambda)\\text{ for }A=\\begin{pmatrix}1&1\\\\0&2\\end{pmatrix}`),
                s: withDisplayMath(`\\chi_A(\\lambda)=(1-\\lambda)(2-\\lambda)`),
                tag: "Characteristic polynomial"
              };
            case 9:
              return {
                q: withDisplayMath(`\\text{Compute }\\det(AB)\\text{ if }\\det A=2,\\ \\det B=-3`),
                s: withDisplayMath(`\\det(AB)=-6`),
                tag: "Determinant property"
              };
            default:
              return {
                q: withDisplayMath(`\\text{Find all }x\\text{ such that }\\det\\begin{pmatrix}x&1&0\\\\1&x&1\\\\0&1&x\\end{pmatrix}=0`),
                s: withDisplayMath(`x(x^2-2)=0,\\quad x\\in\\{0,\\sqrt2,-\\sqrt2\\}`),
                tag: "Polynomial determinant"
              };
          }
        }, 140);
      }

return buildPool(() => {
        const type = randInt(1,10);
        switch (type) {
          case 1:
            return {
              q: withDisplayMath(`\\det\\begin{pmatrix}2&1\\\\3&4\\end{pmatrix}`),
              s: withDisplayMath(`5`),
              tag: "2x2 determinant"
            };
          case 2:
            return {
              q: withDisplayMath(`\\det\\begin{pmatrix}1&2&3\\\\0&1&4\\\\5&6&0\\end{pmatrix}`),
              s: withDisplayMath(`1`),
              tag: "3x3 determinant"
            };
          case 3:
            return {
              q: withDisplayMath(`\\text{Find }A^{-1}\\text{ for }A=\\begin{pmatrix}1&1\\\\0&2\\end{pmatrix}`),
              s: withDisplayMath(`\\begin{pmatrix}1&-\\frac12\\\\0&\\frac12\\end{pmatrix}`),
              tag: "Inverse"
            };
          case 4:
            return {
              q: withDisplayMath(`\\text{Compute }AB\\text{ for }A=\\begin{pmatrix}1&2\\\\0&1\\end{pmatrix},\\ B=\\begin{pmatrix}2&0\\\\1&1\\end{pmatrix}`),
              s: withDisplayMath(`\\begin{pmatrix}4&2\\\\1&1\\end{pmatrix}`),
              tag: "Product"
            };
          case 5:
            return {
              q: withDisplayMath(`\\text{Is }A=\\begin{pmatrix}1&2\\\\2&4\\end{pmatrix}\\text{ invertible?}`),
              s: withDisplayMath(`\\text{No}`),
              tag: "Invertibility"
            };
          case 6:
            return {
              q: withDisplayMath(`\\text{Compute }\\chi_A(\\lambda)\\text{ for }A=\\begin{pmatrix}1&1\\\\0&2\\end{pmatrix}`),
              s: withDisplayMath(`(1-\\lambda)(2-\\lambda)`),
              tag: "Characteristic polynomial"
            };
          case 7:
            return {
              q: withDisplayMath(`\\det\\begin{pmatrix}2&1&0\\\\1&2&1\\\\0&1&2\\end{pmatrix}`),
              s: withDisplayMath(`4`),
              tag: "3x3 determinant"
            };
          case 8:
            return {
              q: withDisplayMath(`\\operatorname{tr}\\begin{pmatrix}1&2&0\\\\0&3&1\\\\1&0&2\\end{pmatrix}`),
              s: withDisplayMath(`6`),
              tag: "Trace"
            };
          case 9:
            return {
              q: withDisplayMath(`\\det(AB)\\text{ if }\\det A=2,\\ \\det B=-3`),
              s: withDisplayMath(`-6`),
              tag: "Property"
            };
          default:
            return {
              q: withDisplayMath(`\\text{Find the adjugate of }\\begin{pmatrix}1&2\\\\3&4\\end{pmatrix}`),
              s: withDisplayMath(`\\begin{pmatrix}4&-2\\\\-3&1\\end{pmatrix}`),
              tag: "Adjugate"
            };
          }
      }, 130);
    }

if (level === "hard") {
        return buildPool(() => {
          const type = randInt(1,10);
          switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\text{Find a basis and the dimension of }W=\\{(x,y,z,t)\\in\\mathbb{R}^4:x+y+z+t=0,\\ x-z=0\\}`),
                s: withDisplayMath(`W=\\operatorname{span}\\{(-1,0,1,0),(-1,1,1,-1)\\},\\quad \\dim W=2`),
                tag: "Subspace with equations"
              };
            case 2:
              return {
                q: withDisplayMath(`T:\\mathbb{R}^3\\to\\mathbb{R}^2,\\ T(x,y,z)=(x+y,y+z).\\ \\text{Find }\\ker T\\text{ and }\\operatorname{Im}T.`),
                s: withDisplayMath(`\\ker T=\\operatorname{span}\\{(1,-1,1)\\},\\quad \\operatorname{Im}T=\\mathbb{R}^2`),
                tag: "Kernel and image"
              };
            case 3:
              return {
                q: withDisplayMath(`\\text{Determine whether }\\{1+x,\\ x+x^2,\\ 1+x^2\\}\\text{ is a basis of }P_2(\\mathbb{R})`),
                s: withDisplayMath(`\\text{Yes}`),
                tag: "Polynomial basis"
              };
            case 4:
              return {
                q: withDisplayMath(`\\text{Find the matrix of }T:\\mathbb{R}^2\\to\\mathbb{R}^2,\\ T(x,y)=(2x-y,x+3y)`),
                s: withDisplayMath(`\\begin{pmatrix}2&-1\\\\1&3\\end{pmatrix}`),
                tag: "Matrix of linear map"
              };
            case 5:
              return {
                q: withDisplayMath(`\\text{Let }T:\\mathbb{R}^3\\to\\mathbb{R}^3\\text{ be defined by }T(x,y,z)=(x-y,y-z,z-x).\\ \\text{Find }\\dim\\ker T.`),
                s: withDisplayMath(`\\dim\\ker T=1`),
                tag: "Kernel dimension"
              };
            case 6:
              return {
                q: withDisplayMath(`\\text{Extend }\\{(1,0,1),(0,1,1)\\}\\text{ to a basis of }\\mathbb{R}^3`),
                s: withDisplayMath(`\\text{One possible basis is }\\{(1,0,1),(0,1,1),(1,0,0)\\}`),
                tag: "Basis extension"
              };
            case 7:
              return {
                q: withDisplayMath(`\\text{Find coordinates of }(1,2)\\text{ in the basis }\\mathcal{B}=\\{(1,1),(1,-1)\\}`),
                s: withDisplayMath(`[(1,2)]_{\\mathcal B}=\\left(\\frac{3}{2},-\\frac{1}{2}\\right)`),
                tag: "Change of basis"
              };
            case 8:
              return {
                q: withDisplayMath(`\\text{Is }W=\\{p\\in P_3(\\mathbb{R}):p(1)=0\\}\\text{ a subspace? Find its dimension.}`),
                s: withDisplayMath(`\\text{Yes},\\quad \\dim W=3`),
                tag: "Polynomial subspace"
              };
            case 9:
              return {
                q: withDisplayMath(`T:\\mathbb{R}^2\\to\\mathbb{R}^2,\\ T(x,y)=(x+y,x+y).\\ \\text{Is }T\\text{ injective? surjective?}`),
                s: withDisplayMath(`\\text{Neither injective nor surjective}`),
                tag: "Injective/surjective"
              };
            default:
              return {
                q: withDisplayMath(`\\text{Find a basis of }U\\cap V\\text{ where }U=\\operatorname{span}\\{(1,0,1),(0,1,1)\\},\\ V=\\operatorname{span}\\{(1,1,2)\\}`),
                s: withDisplayMath(`U\\cap V=\\operatorname{span}\\{(1,1,2)\\}`),
                tag: "Intersection of subspaces"
              };
          }
        }, 140);
      }

return buildPool(() => {
        const type = randInt(1,10);
        switch (type) {
          case 1:
            return {
              q: withDisplayMath(`\\text{Is }W=\\{(x,y,z)\\in\\mathbb{R}^3:x+y+z=0\\}\\text{ a subspace?}`),
              s: withDisplayMath(`\\text{Yes}`),
              tag: "Subspace"
            };
          case 2:
            return {
              q: withDisplayMath(`\\text{Find a basis of }W=\\{(x,y,z):x+y+z=0\\}`),
              s: withDisplayMath(`\\{(1,-1,0),(1,0,-1)\\}`),
              tag: "Basis"
            };
          case 3:
            return {
              q: withDisplayMath(`\\text{Find }\\dim\\operatorname{span}\\{(1,0,0),(0,1,0),(1,1,0)\\}`),
              s: withDisplayMath(`2`),
              tag: "Dimension"
            };
          case 4:
            return {
              q: withDisplayMath(`T(x,y)=(x+y,y).\\ \\text{Find the matrix of }T`),
              s: withDisplayMath(`\\begin{pmatrix}1&1\\\\0&1\\end{pmatrix}`),
              tag: "Linear map"
            };
          case 5:
            return {
              q: withDisplayMath(`T:\\mathbb{R}^3\\to\\mathbb{R}^2,\\ T(x,y,z)=(x+y,y+z).\\ \\text{Find }\\ker T`),
              s: withDisplayMath(`\\operatorname{span}\\{(1,-1,1)\\}`),
              tag: "Kernel"
            };
          case 6:
            return {
              q: withDisplayMath(`\\text{Is }\\{1+x,\\ x+x^2,\\ 1+x^2\\}\\text{ a basis of }P_2(\\mathbb{R})?`),
              s: withDisplayMath(`\\text{Yes}`),
              tag: "Polynomial basis"
            };
          case 7:
            return {
              q: withDisplayMath(`\\text{Find coordinates of }(1,2)\\text{ in }\\mathcal{B}=\\{(1,1),(1,-1)\\}`),
              s: withDisplayMath(`\\left(\\frac{3}{2},-\\frac12\\right)`),
              tag: "Coordinates"
            };
          case 8:
            return {
              q: withDisplayMath(`\\text{Is }T(x,y)=(x+y,1)\\text{ linear?}`),
              s: withDisplayMath(`\\text{No}`),
              tag: "Linearity"
            };
          case 9:
            return {
              q: withDisplayMath(`\\text{Find }\\dim P_3(\\mathbb{R})`),
              s: withDisplayMath(`4`),
              tag: "Polynomial space"
            };
          default:
            return {
              q: withDisplayMath(`\\text{Do }(1,1,0),(1,0,1),(0,1,1)\\text{ form a basis of }\\mathbb{R}^3?`),
              s: withDisplayMath(`\\text{Yes}`),
              tag: "Basis test"
            };
          }
      }, 130);
    }

if (level === "hard") {
        return buildPool(() => {
          const type = randInt(1,10);
          switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\text{Diagonalize }A=\\begin{pmatrix}2&1\\\\1&2\\end{pmatrix}`),
                s: withDisplayMath(`\\lambda_1=3\\text{ with eigenvector }(1,1),\\ \\lambda_2=1\\text{ with eigenvector }(1,-1),\\ \\text{so }A=PDP^{-1}`),
                tag: "Diagonalization"
              };
            case 2:
              return {
                q: withDisplayMath(`\\text{Find the eigenvalues and eigenspaces of }A=\\begin{pmatrix}1&1&0\\\\0&2&0\\\\0&0&2\\end{pmatrix}`),
                s: withDisplayMath(`\\lambda=1\\Rightarrow E_1=\\operatorname{span}\\{(1,0,0)\\},\\quad \\lambda=2\\Rightarrow E_2=\\operatorname{span}\\{(1,1,0),(0,0,1)\\}`),
                tag: "Repeated eigenvalue"
              };
            case 3:
              return {
                q: withDisplayMath(`\\text{Is }A=\\begin{pmatrix}2&1\\\\0&2\\end{pmatrix}\\text{ diagonalizable?}`),
                s: withDisplayMath(`\\text{No. The eigenspace for }\\lambda=2\\text{ has dimension }1`),
                tag: "Defective matrix"
              };
            case 4:
              return {
                q: withDisplayMath(`\\text{Find }A^n\\text{ for }A=\\begin{pmatrix}1&0\\\\0&2\\end{pmatrix}`),
                s: withDisplayMath(`A^n=\\begin{pmatrix}1&0\\\\0&2^n\\end{pmatrix}`),
                tag: "Powers via eigenvalues"
              };
            case 5:
              return {
                q: withDisplayMath(`\\text{Find the characteristic polynomial of }A=\\begin{pmatrix}1&1&0\\\\1&1&0\\\\0&0&3\\end{pmatrix}`),
                s: withDisplayMath(`\\chi_A(\\lambda)=(3-\\lambda)\\lambda(2-\\lambda)`),
                tag: "Characteristic polynomial"
              };
            case 6:
              return {
                q: withDisplayMath(`\\text{A matrix has characteristic polynomial }(\\lambda-1)^2(\\lambda+2).\\ \\text{What are its eigenvalues and algebraic multiplicities?}`),
                s: withDisplayMath(`1\\text{ of multiplicity }2,\\quad -2\\text{ of multiplicity }1`),
                tag: "Interpretation"
              };
            case 7:
              return {
                q: withDisplayMath(`\\text{Find the eigenvalues of }A=\\begin{pmatrix}0&-1\\\\1&0\\end{pmatrix}\\text{ over }\\mathbb{R}`),
                s: withDisplayMath(`\\text{No real eigenvalues}`),
                tag: "Real field"
              };
            case 8:
              return {
                q: withDisplayMath(`\\text{Find }\\operatorname{tr}A\\text{ and }\\det A\\text{ if the eigenvalues are }2,2,-1`),
                s: withDisplayMath(`\\operatorname{tr}A=3,\\quad \\det A=-4`),
                tag: "Trace and determinant"
              };
            case 9:
              return {
                q: withDisplayMath(`\\text{Find an orthogonal diagonalization of }A=\\begin{pmatrix}2&1\\\\1&2\\end{pmatrix}`),
                s: withDisplayMath(`Q=\\frac{1}{\\sqrt2}\\begin{pmatrix}1&1\\\\1&-1\\end{pmatrix},\\quad Q^TAQ=\\begin{pmatrix}3&0\\\\0&1\\end{pmatrix}`),
                tag: "Spectral theorem"
              };
            default:
              return {
                q: withDisplayMath(`\\text{Find the minimal polynomial candidate from }A=\\begin{pmatrix}2&0\\\\0&3\\end{pmatrix}`),
                s: withDisplayMath(`m_A(x)=(x-2)(x-3)`),
                tag: "Minimal polynomial"
              };
          }
        }, 140);
      }

return buildPool(() => {
        const type = randInt(1,10);
        switch (type) {
          case 1:
            return {
              q: withDisplayMath(`\\text{Find the eigenvalues of }A=\\begin{pmatrix}2&0\\\\0&3\\end{pmatrix}`),
              s: withDisplayMath(`2,3`),
              tag: "Diagonal matrix"
            };
          case 2:
            return {
              q: withDisplayMath(`\\text{Find the eigenvalues of }A=\\begin{pmatrix}1&1\\\\0&2\\end{pmatrix}`),
              s: withDisplayMath(`1,2`),
              tag: "Triangular matrix"
            };
          case 3:
            return {
              q: withDisplayMath(`\\text{Is }A=\\begin{pmatrix}2&1\\\\0&2\\end{pmatrix}\\text{ diagonalizable?}`),
              s: withDisplayMath(`\\text{No}`),
              tag: "Defective matrix"
            };
          case 4:
            return {
              q: withDisplayMath(`\\text{Diagonalize }A=\\begin{pmatrix}2&1\\\\1&2\\end{pmatrix}`),
              s: withDisplayMath(`\\lambda=3,1\\text{ with eigenvectors }(1,1),(1,-1)`),
              tag: "Diagonalization"
            };
          case 5:
            return {
              q: withDisplayMath(`\\chi_A(\\lambda)\\text{ for }A=\\begin{pmatrix}0&1\\\\1&0\\end{pmatrix}`),
              s: withDisplayMath(`\\lambda^2-1`),
              tag: "Characteristic polynomial"
            };
          case 6:
            return {
              q: withDisplayMath(`\\text{If the eigenvalues are }1,2,3,\\text{ compute }\\det A`),
              s: withDisplayMath(`6`),
              tag: "Determinant"
            };
          case 7:
            return {
              q: withDisplayMath(`\\text{If the eigenvalues are }2,2,-1,\\text{ compute }\\operatorname{tr}A`),
              s: withDisplayMath(`3`),
              tag: "Trace"
            };
          case 8:
            return {
              q: withDisplayMath(`\\text{Find a basis of the eigenspace for }\\lambda=2\\text{ of }A=\\begin{pmatrix}2&1\\\\0&2\\end{pmatrix}`),
              s: withDisplayMath(`\\operatorname{span}\\{(1,0)\\}`),
              tag: "Eigenspace"
            };
          case 9:
            return {
              q: withDisplayMath(`\\text{Find real eigenvalues of }\\begin{pmatrix}0&-1\\\\1&0\\end{pmatrix}`),
              s: withDisplayMath(`\\text{None}`),
              tag: "Real field"
            };
          default:
            return {
              q: withDisplayMath(`\\text{Find }A^n\\text{ for }A=\\begin{pmatrix}1&0\\\\0&2\\end{pmatrix}`),
              s: withDisplayMath(`\\begin{pmatrix}1&0\\\\0&2^n\\end{pmatrix}`),
              tag: "Powers"
            };
          }
      }, 130);
    }

if (level === "hard") {
        return buildPool(() => {
          const type = randInt(1,10);
          switch (type) {
            case 1:
              return {
                q: withDisplayMath(`\\text{Apply Gram-Schmidt to }(1,1,0),(1,0,1)`),
                s: withDisplayMath(`u_1=(1,1,0),\\quad u_2=\\left(\\frac12,-\\frac12,1\\right),\\text{ then normalize.}`),
                tag: "Gram-Schmidt"
              };
            case 2:
              return {
                q: withDisplayMath(`\\text{Project }(1,2,3)\\text{ onto }\\operatorname{span}\\{(1,1,1)\\}`),
                s: withDisplayMath(`\\operatorname{proj}(1,2,3)=2(1,1,1)=(2,2,2)`),
                tag: "Projection"
              };
            case 3:
              return {
                q: withDisplayMath(`q(x,y)=x^2+4xy+y^2.\\ \\text{Classify the quadratic form.}`),
                s: withDisplayMath(`\\text{Indefinite, since the matrix }\\begin{pmatrix}1&2\\\\2&1\\end{pmatrix}\\text{ has eigenvalues }3,-1`),
                tag: "Quadratic form classification"
              };
            case 4:
              return {
                q: withDisplayMath(`\\text{Find the orthogonal complement of }U=\\operatorname{span}\\{(1,1,0)\\}\\subset\\mathbb{R}^3`),
                s: withDisplayMath(`U^\\perp=\\{(x,y,z):x+y=0\\}=\\operatorname{span}\\{(1,-1,0),(0,0,1)\\}`),
                tag: "Orthogonal complement"
              };
            case 5:
              return {
                q: withDisplayMath(`\\text{Find the least-squares solution of }x+y=1,\\ x-y=0,\\ x+y=2`),
                s: withDisplayMath(`A=\\begin{pmatrix}1&1\\\\1&-1\\\\1&1\\end{pmatrix},\\ b=\\begin{pmatrix}1\\\\0\\\\2\\end{pmatrix},\\ \\hat x=\\left(\\frac34,\\frac34\\right)`),
                tag: "Least squares"
              };
            case 6:
              return {
                q: withDisplayMath(`\\text{Determine whether }A=\\begin{pmatrix}2&1\\\\1&2\\end{pmatrix}\\text{ is positive definite}`),
                s: withDisplayMath(`\\text{Yes, since eigenvalues are }3,1>0`),
                tag: "Positive definite matrix"
              };
            case 7:
              return {
                q: withDisplayMath(`\\text{Diagonalize orthogonally }A=\\begin{pmatrix}2&1\\\\1&2\\end{pmatrix}`),
                s: withDisplayMath(`Q=\\frac{1}{\\sqrt2}\\begin{pmatrix}1&1\\\\1&-1\\end{pmatrix},\\quad Q^TAQ=\\begin{pmatrix}3&0\\\\0&1\\end{pmatrix}`),
                tag: "Spectral theorem"
              };
            case 8:
              return {
                q: withDisplayMath(`q(x,y,z)=x^2+y^2-z^2.\\ \\text{Classify }q`),
                s: withDisplayMath(`\\text{Indefinite}`),
                tag: "Signature"
              };
            case 9:
              return {
                q: withDisplayMath(`\\text{Find }\\operatorname{dist}((1,2),\\operatorname{span}\\{(1,0)\\})`),
                s: withDisplayMath(`2`),
                tag: "Distance to subspace"
              };
            default:
              return {
                q: withDisplayMath(`\\text{Determine whether }(1,1),(1,-1)\\text{ is an orthogonal basis of }\\mathbb R^2`),
                s: withDisplayMath(`\\text{Yes}`),
                tag: "Orthogonal basis"
              };
          }
        }, 140);
      }

return buildPool(() => {
        const type = randInt(1,10);
        switch (type) {
          case 1:
            return {
              q: withDisplayMath(`(1,2)\\cdot(3,-1)`),
              s: withDisplayMath(`1`),
              tag: "Dot product"
            };
          case 2:
            return {
              q: withDisplayMath(`\\|(1,2,2)\\|`),
              s: withDisplayMath(`3`),
              tag: "Norm"
            };
          case 3:
            return {
              q: withDisplayMath(`\\text{Are }(1,1,0)\\text{ and }(1,-1,2)\\text{ orthogonal?}`),
              s: withDisplayMath(`\\text{Yes}`),
              tag: "Orthogonality"
            };
          case 4:
            return {
              q: withDisplayMath(`\\text{Project }(1,2)\\text{ onto }\\operatorname{span}\\{(1,0)\\}`),
              s: withDisplayMath(`(1,0)`),
              tag: "Projection"
            };
          case 5:
            return {
              q: withDisplayMath(`q(x,y)=x^2+y^2.\\ \\text{Is }q\\text{ positive definite?}`),
              s: withDisplayMath(`\\text{Yes}`),
              tag: "Quadratic form"
            };
          case 6:
            return {
              q: withDisplayMath(`\\text{Find the matrix of }q(x,y)=x^2+2xy+y^2`),
              s: withDisplayMath(`\\begin{pmatrix}1&1\\\\1&1\\end{pmatrix}`),
              tag: "Associated matrix"
            };
          case 7:
            return {
              q: withDisplayMath(`\\text{Find }U^\\perp\\text{ for }U=\\operatorname{span}\\{(1,1,0)\\}`),
              s: withDisplayMath(`\\{(x,y,z):x+y=0\\}`),
              tag: "Orthogonal complement"
            };
          case 8:
            return {
              q: withDisplayMath(`\\text{Classify }q(x,y)=x^2+4xy+y^2`),
              s: withDisplayMath(`\\text{Indefinite}`),
              tag: "Classification"
            };
          case 9:
            return {
              q: withDisplayMath(`\\text{Find the angle between }(1,0)\\text{ and }(0,1)`),
              s: withDisplayMath(`\\frac{\\pi}{2}`),
              tag: "Angle"
            };
          default:
            return {
              q: withDisplayMath(`\\text{Determine whether }(1,1),(1,-1)\\text{ is an orthogonal basis of }\\mathbb R^2`),
              s: withDisplayMath(`\\text{Yes}`),
              tag: "Orthogonal basis"
            };
          }
      }, 130);
    }

function generatorForTopic(topic, level) {
      switch (topic) {
        case "systems": return systemsTemplates(level);
        case "matrices": return matricesTemplates(level);
        case "vector-spaces": return vectorSpacesTemplates(level);
        case "eigen": return eigenTemplates(level);
        case "orthogonality": return orthogonalityTemplates(level);
        default: return [];
      }
    }

function buildExercises(topic, count, level) {
      const pool = generatorForTopic(topic, level);
      return sampleExercises(pool, count);
    }

let currentTopic = "systems";
    let solutionsVisible = false;
    let currentExercises = [];

function labelForTopic(topic) {
      switch (topic) {
        case "systems": return "Linear Systems";
        case "matrices": return "Matrices & Determinants";
        case "vector-spaces": return "Vector Spaces & Linear Maps";
        case "eigen": return "Eigenvalues & Diagonalization";
        case "orthogonality": return "Orthogonality & Quadratic Forms";
        case "exam": return "Exam Mode";
        default: return "Worksheet";
      }
    }

function defaultTitleForTopic(topic) {
      switch (topic) {
        case "systems": return "Linear Systems Worksheet";
        case "matrices": return "Matrices and Determinants Worksheet";
        case "vector-spaces": return "Vector Spaces and Linear Maps Worksheet";
        case "eigen": return "Eigenvalues and Diagonalization Worksheet";
        case "orthogonality": return "Orthogonality and Quadratic Forms Worksheet";
        case "exam": return "Geometry and Linear Algebra Exam Practice";
        default: return "Geometry and Linear Algebra Worksheet";
      }
    }