What programs mean (the languages, translators, Mojo checker and
interpreter, prover, fuzzer, machine model, catalog problems and the Mojo
corpus with godbolt's stored answers) was mixed into the site's tree, so a
change to the prover and a change to a button went through the same gate
and the same docs. This moves all of it under core/, laid out as its own
repository, ready to be extracted with its history and pinned here as a
git submodule.
- core/: src/{engines,services,sync,mojo,exercises,curriculum,common},
mojo/, syntax/mojo.xml, its tests (with Workspace and workForProblem in
place of the site's Session), scripts (corpus pipeline, play, the
exercise and probe starters, engines export/diff), and its docs
(engines, trust, mojo-corpus, exercises, coverage). Its own pixi.toml,
package.json, README, AGENTS.md and CI workflow.
- core/tests/boundary.test.mjs: library modules use no DOM, import no
page widget, and import nothing outside src/.
- core/scripts/cli.mjs: pixi run cli check|run|prove|fuzz|translate.
- core/scripts/dafny.py: Dafny 4.11.0 pinned by version and SHA-256 per
platform, fetched into .tools/ (pixi run dafny-fetch, pixi run dafny).
- The site imports core only as #core/<path>.js: an import map in
index.html, "imports" in package.json for node, core's declarations for
tsc. The site's TypeScript builds core first (npm run build).
- assemble.sh, the Quarto engine copy, the render cache key, check-pages,
quarto-export and quarto-css read core/dist and core/mojo; quarto-css
copies core's syntax/mojo.xml into the extension.
- Site tests that covered engines moved to core; the rest keep Session.
- README, AGENTS.md, docs/app.md, docs/deploy.md and the CI workflow
describe the split (checkout with submodules; core's tests and corpus
status run against the pinned commit).
Gate: site 110 pass; core 307 pass; corpus status --strict passes.
Manual check: the assembled site opens Bridge (count-base-proved),
Developer and Hardware (count-base) with the editor, the stepper and the
board, and no module errors.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
235 lines
10 KiB
JavaScript
235 lines
10 KiB
JavaScript
// Stage 6: pseudo -> matho. For the programs that are equations, the generated LaTeX must read, lower back to
|
|
// pseudo that behaves like the original, and be a fixed point; every other program is refused with the construct
|
|
// and its line. The equation sets are the ones tests/matho.test.mjs checks by hand-worked values.
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { programs, EQUATIONS } from './helpers/sync-programs.mjs';
|
|
import { studyOf, runPseudo } from '../dist/services/pseudo.js';
|
|
import { parseMatho } from '../dist/services/matho.js';
|
|
import { pseudoToMatho } from '../dist/sync/pseudo-to-matho.js';
|
|
|
|
globalThis.localStorage = { getItem() { return null; }, setItem() { }, removeItem() { } };
|
|
|
|
/**
|
|
* Equations the reader lowers but this generator does not write back, and why. An equation leaves this list
|
|
* when it round-trips; the test fails if a listed equation does, so the list can only shrink.
|
|
*/
|
|
const KNOWN_GAPS = {
|
|
'matrix-row': 'the row index i is an input that only subscripts, and the reader recognizes that only for a left side written y_i, with the function name carrying the subscript',
|
|
'choose': 'the reader names the second factorial counter K2 (K is the input), and a loop counter has to be a single letter in matho',
|
|
};
|
|
|
|
const SUPPORTED_AT_LEAST = 24; // raise as matho learns more forms; counted below
|
|
|
|
const num = (line) => { const m = /returned (.*)$/.exec(line ?? ''); return m ? m[1] : null; };
|
|
function run(pseudo, call, input = []) {
|
|
const st = studyOf(pseudo);
|
|
assert.ok(st.ok, `pseudo should study: ${st.diagnostics.filter((d) => d.severity === 'error').map((d) => d.message).join(' | ')}`);
|
|
const t = runPseudo(st, { call, input, maxSteps: 200000 });
|
|
return { value: t.error ? `error:${t.error.kind}` : num(t.output[t.output.length - 1]), out: t.error ? [] : t.output.slice(0, -1) };
|
|
}
|
|
const same = (a, b) => a.value === b.value || (!Number.isNaN(Number(a.value)) && !Number.isNaN(Number(b.value)) && Math.abs(Number(a.value) - Number(b.value)) <= 1e-9 * Math.max(1, Math.abs(Number(a.value)))) && JSON.stringify(a.out) === JSON.stringify(b.out);
|
|
const lowerPseudo = (latex) => { const r = parseMatho(latex); assert.ok(r.ok, `the generated equations should read: ${latex}\n${r.diagnostics.map((d) => d.message).join(' | ')}`); return r.program.pseudo; };
|
|
|
|
const results = new Map();
|
|
test('every equation set: the LaTeX reads, lowers to pseudo that behaves like the original, and is a fixed point; or it is a listed gap', () => {
|
|
const problems = [];
|
|
let ok = 0;
|
|
for (const [id, [src, call]] of Object.entries(EQUATIONS)) {
|
|
const first = parseMatho(src);
|
|
assert.ok(first.ok, `${id}: the fixture should lower`);
|
|
const pseudo = first.program.pseudo;
|
|
const m = pseudoToMatho(pseudo);
|
|
results.set(id, m);
|
|
const known = KNOWN_GAPS[id];
|
|
if ('unsupported' in m) {
|
|
if (!known) problems.push(`${id}: ${m.unsupported.map((d) => d.message).join(' | ')}`);
|
|
continue;
|
|
}
|
|
if (known) { problems.push(`${id}: now round-trips; take it off KNOWN_GAPS (${known})`); continue; }
|
|
ok++;
|
|
// reads, and same behavior: the original equations' pseudo and the pseudo of the written equations
|
|
let again;
|
|
try { again = lowerPseudo(m.source); } catch (e) { problems.push(`${id}: ${e.message}`); continue; }
|
|
const a = run(pseudo, call); const b = run(again, call);
|
|
if (!same(a, b)) problems.push(`${id}: behavior differs: ${JSON.stringify(a)} vs ${JSON.stringify(b)}`);
|
|
// fixed point
|
|
const m2 = pseudoToMatho(again);
|
|
if ('unsupported' in m2) { problems.push(`${id}: the lowered pseudo is no longer supported: ${m2.unsupported[0].message}`); continue; }
|
|
if (m2.source !== m.source) problems.push(`${id}: not a fixed point:\n${m.source}\nvs\n${m2.source}`);
|
|
}
|
|
assert.deepEqual(problems, []);
|
|
assert.ok(ok >= SUPPORTED_AT_LEAST, `${ok} equation sets round-trip, fewer than ${SUPPORTED_AT_LEAST}`);
|
|
});
|
|
|
|
test('every exercise and corpus program: accepted and checked the same way, or refused with a reason and a line', () => {
|
|
let accepted = 0;
|
|
for (const p of programs()) {
|
|
if (!studyOf(p.pseudo).ok) continue;
|
|
const m = pseudoToMatho(p.pseudo);
|
|
if ('unsupported' in m) {
|
|
assert.ok(m.unsupported.length > 0, p.id);
|
|
for (const d of m.unsupported) {
|
|
assert.ok(Number.isInteger(d.line) && d.line >= 1 && d.line <= p.pseudo.split('\n').length, `${p.id}: line ${d.line}`);
|
|
assert.ok(d.message.length > 20, p.id);
|
|
}
|
|
continue;
|
|
}
|
|
accepted++;
|
|
const again = lowerPseudo(m.source);
|
|
if (p.call) assert.ok(same(run(p.pseudo, p.call), run(again, p.call)), `${p.id}: behavior differs`);
|
|
const m2 = pseudoToMatho(again);
|
|
assert.ok(!('unsupported' in m2) && m2.source === m.source, `${p.id}: not a fixed point`);
|
|
}
|
|
assert.ok(accepted >= 3, `${accepted} exercise, corpus, and fixture programs are equations, fewer than 3`);
|
|
});
|
|
|
|
test('a program that is not an equation is refused with the construct and its line', () => {
|
|
const ask = (pseudo) => { const r = pseudoToMatho(pseudo); assert.ok('unsupported' in r, pseudo); return r.unsupported.map((d) => d.message).join(' | '); };
|
|
assert.match(ask(`FUNCTION COUNT_DOWN(N : INTEGER) RETURNS INTEGER
|
|
DECLARE K : INTEGER
|
|
K <- N
|
|
WHILE K > 0
|
|
K <- K - 1
|
|
ENDWHILE
|
|
RETURN K
|
|
ENDFUNCTION
|
|
`), /matho has no form for a WHILE loop \(line 4\)/);
|
|
assert.match(ask(`FUNCTION F(N : INTEGER) RETURNS INTEGER
|
|
OUTPUT N
|
|
RETURN N
|
|
ENDFUNCTION
|
|
`), /OUTPUT.*\(line 2\)/);
|
|
assert.match(ask(`FUNCTION SHOUT(T : STRING) RETURNS STRING
|
|
RETURN T
|
|
ENDFUNCTION
|
|
`), /(answers STRING|not a number).*\(line 1\)/);
|
|
assert.match(ask(`FUNCTION F(N : INTEGER) RETURNS INTEGER
|
|
IF N > 0 THEN
|
|
IF N > 1 THEN
|
|
RETURN 2
|
|
ELSE
|
|
RETURN 1
|
|
ENDIF
|
|
ELSE
|
|
RETURN 0
|
|
ENDIF
|
|
ENDFUNCTION
|
|
`), /nested IF.*\(line 3\)/);
|
|
assert.match(ask('OUTPUT 1 + 2\n'), /steps outside a function/);
|
|
assert.match(ask('FUNCTION F(\n'), /./);
|
|
});
|
|
|
|
test('names: SIGMA is \\sigma, X_BAR is \\bar{x}, a single letter is lower case, and a hint restores the student\'s own spelling', () => {
|
|
const pseudo = `FUNCTION X_BAR(N : INTEGER, X : LIST OF FLOAT) RETURNS FLOAT
|
|
DECLARE Total : FLOAT
|
|
Total <- 0.0
|
|
FOR I <- 0 TO N
|
|
Total <- Total + X[I]
|
|
NEXT I
|
|
RETURN 1 / N * Total
|
|
ENDFUNCTION
|
|
|
|
FUNCTION SIGMA(V : FLOAT) RETURNS FLOAT
|
|
RETURN V * V
|
|
ENDFUNCTION
|
|
`;
|
|
const plain = pseudoToMatho(pseudo);
|
|
assert.ok(!('unsupported' in plain), JSON.stringify(plain));
|
|
assert.match(plain.source, /^\\bar\{x\} = /m);
|
|
assert.match(plain.source, /^\\sigma = /m);
|
|
assert.match(plain.source, /x_\{i\}/);
|
|
const hinted = pseudoToMatho(pseudo, { names: { X_BAR: '\\overline{x}' } });
|
|
assert.ok(!('unsupported' in hinted), JSON.stringify(hinted));
|
|
assert.match(hinted.source, /^\\overline\{x\} = /m);
|
|
assert.equal(parseMatho(hinted.source).program.defs[0].name, 'X_BAR');
|
|
});
|
|
|
|
test('a hint that does not lower back to the function is not trusted', () => {
|
|
const r = pseudoToMatho(`FUNCTION SQUARE(V : FLOAT) RETURNS FLOAT
|
|
RETURN V * V
|
|
ENDFUNCTION
|
|
`, { names: { SQUARE: 'q' } });
|
|
assert.ok('unsupported' in r);
|
|
assert.match(r.unsupported[0].message, /SQUARE comes back as/);
|
|
});
|
|
|
|
test('the line map has one entry per output line and points inside the pseudo', () => {
|
|
for (const [id, [src]] of Object.entries(EQUATIONS)) {
|
|
const m = results.get(id) ?? pseudoToMatho(parseMatho(src).program.pseudo);
|
|
if ('unsupported' in m) continue;
|
|
const lines = m.source.replace(/\n$/, '').split('\n');
|
|
assert.equal(m.map.length, lines.length, id);
|
|
const n = parseMatho(src).program.pseudo.split('\n').length;
|
|
for (const x of m.map) assert.ok(x === null || (Number.isInteger(x) && x >= 1 && x <= n), `${id}: ${x}`);
|
|
}
|
|
});
|
|
|
|
test('a sum from 1 reads x_i for the pseudo\'s X[I - 1], and a sum from 0 reads x_i for X[I]', () => {
|
|
const from1 = pseudoToMatho(parseMatho(EQUATIONS['sum-from-one'][0]).program.pseudo);
|
|
assert.match(from1.source, /\\sum_\{i=1\}\^\{n\} x_\{i\}/);
|
|
const from0 = pseudoToMatho(parseMatho(EQUATIONS['mean'][0]).program.pseudo);
|
|
assert.match(from0.source, /\\sum_\{i=0\}\^\{n-1\} x_\{i\}/);
|
|
// L[I] in a loop the reader would shift is not an equation it can say
|
|
const r = pseudoToMatho(`FUNCTION S(N : INTEGER, L : LIST OF FLOAT) RETURNS FLOAT
|
|
DECLARE Total : FLOAT
|
|
Total <- 0.0
|
|
FOR I <- 1 TO N + 1
|
|
Total <- Total + L[I]
|
|
NEXT I
|
|
RETURN Total
|
|
ENDFUNCTION
|
|
`);
|
|
assert.ok('unsupported' in r);
|
|
assert.match(r.unsupported[0].message, /starts at 1/);
|
|
});
|
|
|
|
/** Pseudo a student wrote by hand (not lowered from matho) that is still an equation: the same three checks. */
|
|
const HAND = {
|
|
'whole-number-types': [`FUNCTION AREA(W : INTEGER, H : INTEGER) RETURNS INTEGER
|
|
RETURN W * H
|
|
ENDFUNCTION
|
|
`, 'AREA(3, 4)'],
|
|
'elseif-chain': [`FUNCTION SIGN(X : FLOAT) RETURNS INTEGER
|
|
IF X < 0 THEN
|
|
RETURN -1
|
|
ELSEIF X == 0 THEN
|
|
RETURN 0
|
|
ENDIF
|
|
RETURN 1
|
|
ENDFUNCTION
|
|
`, 'SIGN(-2.5)'],
|
|
'sum-of-squares-to-n': [`FUNCTION SQUARES(N : INTEGER) RETURNS INTEGER
|
|
DECLARE Total : INTEGER
|
|
Total <- 0
|
|
FOR K <- 1 TO N + 1
|
|
Total <- Total + K * K
|
|
NEXT K
|
|
RETURN Total
|
|
ENDFUNCTION
|
|
`, 'SQUARES(4)'],
|
|
'mean-of-a-list': [`FUNCTION MEAN(L : LIST OF FLOAT) RETURNS FLOAT
|
|
DECLARE Total : FLOAT
|
|
Total <- 0.0
|
|
FOR I <- 0 TO LENGTH(L)
|
|
Total <- Total + L[I]
|
|
NEXT I
|
|
RETURN Total / LENGTH(L)
|
|
ENDFUNCTION
|
|
`, 'MEAN([1.0, 2.0, 6.0])'],
|
|
};
|
|
|
|
test('pseudo written by hand that is an equation: accepted when matho can say it, and held to the same three checks', () => {
|
|
const said = [];
|
|
for (const [id, [pseudo, call]] of Object.entries(HAND)) {
|
|
const m = pseudoToMatho(pseudo);
|
|
if ('unsupported' in m) { assert.equal(id, 'mean-of-a-list', `${id}: ${m.unsupported[0].message}`); continue; }
|
|
said.push(id);
|
|
const again = lowerPseudo(m.source);
|
|
assert.ok(same(run(pseudo, call), run(again, call)), `${id}: ${JSON.stringify(run(pseudo, call))} vs ${JSON.stringify(run(again, call))}`);
|
|
const m2 = pseudoToMatho(again);
|
|
assert.ok(!('unsupported' in m2) && m2.source === m.source, `${id}: not a fixed point`);
|
|
}
|
|
assert.deepEqual(said, ['whole-number-types', 'elseif-chain', 'sum-of-squares-to-n']);
|
|
});
|