Grade exact LaTeX answers as expressions

Author: Edwin Chan

CENTRAL.md

@@ -39,7 +39,7 @@ Stack: Next.js, NextAuth (Google + dev bypass), Prisma, KaTeX for math, Lucide i
 - **Hand-drawn visual system** — `app/globals.css` now provides paper/ink design tokens, graph-paper backgrounds, asymmetric squircle cards and controls, marker-color accents, and irregular badges/tabs. Shared surfaces use native asymmetric borders instead of `border-image`, which created rigid grey rectangles outside rounded controls. Metric cards use the same neutral border on every edge instead of decorative colored strips. Dark structural borders are intentionally quieter, search inputs are borderless at rest with one cyan focus stroke, and selected problem-set tag counts use opaque ink/paper colors for readable contrast. Global wavy eyebrow/title underlines remain removed. A signed-in production Chrome audit of `/problem-sets/1991-ajhsme` also removed percentage shape paths from variable-height panels, fixed oversized panel-header geometry, and removed the blue statement band. Desktop navigation is a 64 px icon rail that expands to 240 px on hover/focus, while mobile retains the stable off-canvas sheet. The simplified Sigma in `public/dbsmo-mark.svg` is shared by favicon metadata and the landing brand. `app/layout.tsx` loads Shantell Sans for display/control text while Inter remains the body and math font. Route-specific coverage was visually audited across dashboard, problem catalog/detail, writeups, practice, classes, leaderboard, users/profiles, settings, and admin surfaces; FTW and Playground were intentionally excluded. Unsupported browsers retain ordinary border/radius fallbacks; details are in `docs/visual-system.md`.
 - **Mobile/classes cleanup** — fixed mobile `/problem-sets` hiding task rows by restoring the responsive card table, stabilized the mobile sidebar grid to avoid icon reflow on tap/focus, and made dashboard auth/actions render as a compact mobile account card. `/classes` now has a teacher/admin `Announcements` subtab that lists existing class messages and supports author/admin deletion. Display-name fallbacks now treat literal `"null"`/`"undefined"` strings as empty via `lib/display-name.ts`.
 - **Mobile sidebar focus fix** — mobile sidebar sheet geometry now remains stable under `:hover`, `:focus`, and `:focus-within`, preventing the nav grid from jumping upward when a mobile tap focuses one of the upper links (source: `app/globals.css`).
-- **Answer previews and LaTeX grading** — Practice and problem-set answer boxes now render a small KaTeX preview above the input using `mathInputToTex(...)`. `lib/grading.ts` normalizes math delimiters and common LaTeX forms through `lib/math-input.ts`, so expression answers and answer keys can use `$...$`, `\sqrt{...}`, coefficients before functions like `5\sqrt{2}-7`, `\frac{...}{...}`, braced powers, and `\pi`.
+- **Answer previews and LaTeX grading** — Practice and problem-set answer boxes now render a small KaTeX preview above the input using `mathInputToTex(...)`. `lib/grading.ts` normalizes math delimiters and common LaTeX forms through `lib/math-input.ts`, so expression answers and answer keys can use `$...$`, `\sqrt{...}`, coefficients before functions like `5\sqrt{2}-7`, `\frac{...}{...}`, braced powers, and `\pi`. `EXACT` answers retain literal text matching but automatically fall back to the same numeric/LaTeX expression comparison when literal matching fails.
 - **Expanded LaTeX statement support** — KaTeX is upgraded to `0.17.x`, the official `mhchem` extension enables `\ce{...}`, and `lib/latex-compat.ts` converts document wrappers plus `tabular`, `tabular*`, `tabularx`, and `longtable` into safe KaTeX-compatible arrays, including standard optional position arguments such as `[t]`. A production sweep of all published 1985-1998 AJHSME sets found and covered six affected expressions in 1987 Q8/Q23, 1989 Q14/Q22, 1990 Q9, and 1991 Q6. Safe MathLive notation aliases map to KaTeX primitives; editor/HTML commands remain unsupported. Rendering keeps `trust: false`, `maxSize: 50`, and `maxExpand: 1000`. See `docs/latex-support.md`.
 - **Legacy LaTeX currency compatibility** — imported contest statements using full-LaTeX `\textdollar` or invalid currency sequences such as `\54` now render through bounded aliases in `lib/latex-compat.ts`; escaped row breaks remain unchanged.
 - **Escape-aware LaTeX parsing and safe aliases** — `LatexStatement` now tokenizes escaped dollar signs, multiline delimiters, image tokens, and matching bare environments without regex delimiter collisions. This fixes HTML imports such as 1996 AJHSME question 18 (`<math>\$2000</math>`). Conservative aliases cover common blackboard/bold, paired-delimiter, calculus, and basic SI-unit notation; legacy `eqnarray`/`flalign`/`multline` displays are downgraded safely. Security remains `trust: false`, `globalGroup: false`, fresh macros per expression, bounded size/expansion, and inert non-math HTML.

app/admin/create/page-client.tsx

@@ -58,7 +58,11 @@ const ANSWER_TYPE_OPTIONS: { value: AnswerType; label: string; hint: string }[]
   { value: "INTEGER", label: "Integer", hint: "e.g. 42" },
   { value: "DECIMAL", label: "Decimal", hint: "e.g. 3.14" },
   { value: "FRACTION", label: "Fraction", hint: "e.g. 3/7" },
-  { value: "EXACT", label: "Exact match", hint: "e.g. triangle" },
+  {
+    value: "EXACT",
+    label: "Exact match",
+    hint: "Text, or equivalent numeric/LaTeX expressions",
+  },
   { value: "SET", label: "Set", hint: "e.g. 1,2,5" },
   { value: "MULTIPLE", label: "Multiple accepted", hint: "Use semicolons (e.g. 3/7; 0.4286)" },
   { value: "EXPRESSION", label: "Expression", hint: "e.g. sqrt(2), 2^0.5, pi/3" },

docs/import-format.md

@@ -117,7 +117,7 @@ Per-problem `topicTags` drive Practice mode.
 
 ## Answer Evaluation Rules
 
-- `EXACT`: normalized string match
+- `EXACT`: normalized string match, with automatic numeric/LaTeX expression fallback
 - `INTEGER`: integer normalization
 - `DECIMAL`: decimal normalization
 - `FRACTION`: simplified fraction comparison
@@ -128,6 +128,8 @@ Per-problem `topicTags` drive Practice mode.
 ### Notes
 
 - Fraction answers like `2/4` are simplified to `1/2`.
+- `EXACT` preserves ordinary text matching, but numeric or LaTeX answers such as
+  `\frac{5}{4}` also accept equivalent expression input such as `5/4` or `1.25`.
 - `FRACTION` does not automatically treat `1/2` and `0.5` as equal. Use `EXPRESSION` if decimal and fractional forms should both pass.
 - `EXPRESSION` supports inputs like `sqrt(2)`, `2^0.5`, `pi/3`, `2pi`, and `3(1+2)`.
 - `EXPRESSION` is numeric only. Symbolic algebra such as `x+1` is not supported.

lib/grading.ts

@@ -56,28 +56,32 @@ export function gradeAnswer(input: GradeInput): GradeResult {
   }
 
   if (input.answerType === "expression") {
-    const tolerance = input.decimalTolerance ?? 1e-9;
-    const answerNumber = evaluateMathExpression(input.rawAnswer);
-    const evaluatedCandidates = [input.answerKey, ...(input.acceptedAnswers ?? [])]
-      .filter(Boolean)
-      .map((answer) => evaluateMathExpression(answer));
-    const normalizedCandidates = evaluatedCandidates.map((candidate) =>
-      Number.isFinite(candidate) ? formatNumber(candidate) : "",
+    return gradeExpressionCandidates(
+      input.rawAnswer,
+      rawCandidates,
+      normalizedAnswer,
+      input.decimalTolerance ?? 1e-9,
     );
-    const isCorrect =
-      Number.isFinite(answerNumber) &&
-      evaluatedCandidates.some(
-        (candidate) =>
-          Number.isFinite(candidate) && numbersMatch(answerNumber, candidate, tolerance),
-      );
+  }
 
-    return {
-      isCorrect,
-      normalizedAnswer: Number.isFinite(answerNumber)
-        ? formatNumber(answerNumber)
-        : normalizedAnswer,
-      normalizedAcceptedAnswers: normalizedCandidates,
+  if (input.answerType === "exact") {
+    const literalResult = {
+      isCorrect: candidates.includes(normalizedAnswer),
+      normalizedAnswer,
+      normalizedAcceptedAnswers: candidates,
     };
+    if (literalResult.isCorrect) {
+      return literalResult;
+    }
+
+    const expressionResult = gradeExpressionCandidates(
+      input.rawAnswer,
+      rawCandidates,
+      normalizedAnswer,
+      input.decimalTolerance ?? 1e-9,
+      true,
+    );
+    return expressionResult.isCorrect ? expressionResult : literalResult;
   }
 
   return {
@@ -87,6 +91,49 @@ export function gradeAnswer(input: GradeInput): GradeResult {
   };
 }
 
+function gradeExpressionCandidates(
+  rawAnswer: string,
+  rawCandidates: string[],
+  fallbackNormalizedAnswer: string,
+  tolerance: number,
+  preserveExactNumericIdentity = false,
+): GradeResult {
+  const answerNumber = evaluateMathExpression(rawAnswer);
+  const evaluatedCandidates = rawCandidates.map((answer) => evaluateMathExpression(answer));
+  const normalizedCandidates = evaluatedCandidates.map((candidate) =>
+    Number.isFinite(candidate) ? formatNumber(candidate) : "",
+  );
+  const answerCanonical = preserveExactNumericIdentity
+    ? canonicalDecimal(normalizeText(rawAnswer, false))
+    : null;
+  const isCorrect =
+    Number.isFinite(answerNumber) &&
+    evaluatedCandidates.some((candidate, index) => {
+      const candidateCanonical = preserveExactNumericIdentity
+        ? canonicalDecimal(normalizeText(rawCandidates[index], false))
+        : null;
+      if (answerCanonical && candidateCanonical) {
+        return answerCanonical === candidateCanonical;
+      }
+      if (
+        preserveExactNumericIdentity &&
+        (Math.abs(answerNumber) > Number.MAX_SAFE_INTEGER ||
+          Math.abs(candidate) > Number.MAX_SAFE_INTEGER)
+      ) {
+        return false;
+      }
+      return Number.isFinite(candidate) && numbersMatch(answerNumber, candidate, tolerance);
+    });
+
+  return {
+    isCorrect,
+    normalizedAnswer: Number.isFinite(answerNumber)
+      ? formatNumber(answerNumber)
+      : fallbackNormalizedAnswer,
+    normalizedAcceptedAnswers: normalizedCandidates,
+  };
+}
+
 export function normalizeAnswer(
   rawAnswer: string,
   answerType: AnswerType,

tests/grading.test.ts

@@ -139,6 +139,55 @@ describe("gradeAnswer", () => {
     expect(result.isCorrect).toBe(true);
   });
 
+  it("automatically evaluates LaTeX answer keys configured as exact", () => {
+    expect(
+      gradeAnswer({
+        answerType: "exact",
+        answerKey: "$\\frac{5}{4}$",
+        rawAnswer: "5/4",
+      }),
+    ).toMatchObject({
+      isCorrect: true,
+      normalizedAnswer: "1.25",
+    });
+
+    expect(
+      gradeAnswer({
+        answerType: "exact",
+        answerKey: "$\\frac{1}{6^{3/2}}$",
+        rawAnswer: "1/(6*sqrt(6))",
+      }).isCorrect,
+    ).toBe(true);
+  });
+
+  it("preserves literal matching for non-mathematical exact answers", () => {
+    expect(
+      gradeAnswer({
+        answerType: "exact",
+        answerKey: "No",
+        rawAnswer: " no ",
+      }).isCorrect,
+    ).toBe(true);
+
+    expect(
+      gradeAnswer({
+        answerType: "exact",
+        answerKey: "No",
+        rawAnswer: "Yes",
+      }).isCorrect,
+    ).toBe(false);
+  });
+
+  it("does not collapse distinct unsafe integers during exact expression fallback", () => {
+    expect(
+      gradeAnswer({
+        answerType: "exact",
+        answerKey: "9007199254740992",
+        rawAnswer: "9007199254740993",
+      }).isCorrect,
+    ).toBe(false);
+  });
+
   it("evaluates coefficients before LaTeX functions", () => {
     const result = gradeAnswer({
       answerType: "expression",