Maxim Dolgolyov
20b8ce2c5b
- таксономия тема→навык (topics/byTopic), метаданные topic/order/subject/grade - 13 генераторов в 3 темах: Уравнения (+a(x+b)=c(x+d), (ax+b)/c=d), Пропорции (3), Проценты (3) - проценты как compute-задачи: текстовый prompt + проверка подстановкой (latex уравнения скрыт) - подробные объяснения: каждый шаг расписан словами + шаг «Проверка» (подстановка корня) - UI: вкладки тем + чипы навыков, бейджи мастерства, авто-выбор первой неосвоенной темы/навыка - движок: exprToLatex чинит отрицательные множители (7·(−5)), поле kind, нумерованные шаги решения - смоуки 238/238 (движок) + 19/19 (страница); план: P1 отмечен DONE Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
344 lines
17 KiB
JavaScript
344 lines
17 KiB
JavaScript
'use strict';
|
||
/* ════════════════════════════════════════════════════════════════════════
|
||
TrainerEngine — ядро ИИ-тренажёра (Фаза 0, прототип).
|
||
|
||
Идея (гибрид): задачи рождаются из ДАННЫХ — «генераторов», а математика
|
||
считается ДЕТЕРМИНИРОВАННО через SimExpr (тот же безопасный вычислитель, что
|
||
у конструктора симуляций; ⛔ без eval/new Function). LLM в этом ядре НЕ
|
||
участвует: его роль — один раз сочинить генераторы (Уровень 0) либо позже
|
||
отдавать текстовые задачи, которые ЭТОТ ЖЕ слой верифицирует подстановкой
|
||
(Уровень 1). Любой источник задачи проходит один и тот же verifyRoot.
|
||
|
||
Генератор (данные):
|
||
{
|
||
id, skill, title,
|
||
pick: { a:[lo,hi], ... }, // целые параметры из диапазонов
|
||
constraint?: "c < a", // булево над pick (SimExpr) — иначе пересэмпл
|
||
derive?: { c: "a*root + b" }, // доп. параметры последовательно (SimExpr)
|
||
require?: "...", // булево после derive — иначе пересэмпл
|
||
lhs, rhs, // СТОРОНЫ уравнения как выражения с {param} и x
|
||
display?, // как показать (по умолч. "lhs = rhs")
|
||
answerVar?: "x", // имя неизвестной (деф. x)
|
||
answer: "root", // корень как формула над параметрами
|
||
integerAnswer?: true, // требовать целый корень
|
||
solution?: ["шаг … {ans}", …] // шаблоны шагов (доступен {ans})
|
||
}
|
||
|
||
Гарантия КОРРЕКТНОСТИ: после материализации движок ПОДСТАВЛЯЕТ заявленный
|
||
корень в уравнение (verifyRoot). Не сходится — экземпляр отбрасывается (в
|
||
strict-режиме — исключение). Та же подстановка проверяет ответ ученика
|
||
(checkStudentAnswer) и автоматически принимает эквивалентные формы
|
||
(5, 5.0, 10/2, "x=15/3", "2+3").
|
||
|
||
API (window.TrainerEngine):
|
||
instantiate(gen, opts) -> problem | null
|
||
generateBatch(gen, n, opts) -> problem[]
|
||
verifyRoot(problem, value) -> { ok, residual, lhs, rhs }
|
||
checkStudentAnswer(problem, input)-> { ok, value, residual, message, reason? }
|
||
makeRng(seed) -> () => [0,1) (детерминизм для тестов/пула)
|
||
|
||
problem:
|
||
{ genId, skill, title, lhsExpr, rhsExpr, display, answerVar, answer,
|
||
params, solution }
|
||
════════════════════════════════════════════════════════════════════════ */
|
||
(function (global) {
|
||
|
||
function SE() {
|
||
var s = global.SimExpr;
|
||
if (!s) throw new Error('TrainerEngine требует SimExpr (подключите _sim_expr.js раньше).');
|
||
return s;
|
||
}
|
||
|
||
// Допуск подстановки: масштабируется величиной сторон, чтобы крупные
|
||
// коэффициенты не давали ложного «не сходится» из-за плавающей арифметики.
|
||
var EPS = 1e-7;
|
||
|
||
/* ── Детерминированный ГПСЧ (mulberry32) — тот же, что в game/map.js ──
|
||
Нужен, чтобы предгенерация пула и тесты были воспроизводимы. В рантайме
|
||
можно не передавать seed (тогда берётся внутренний инкремент от Date нельзя —
|
||
поэтому дефолт фиксирован, а вариативность даёт сам диапазон pick). */
|
||
function makeRng(seed) {
|
||
var s = (seed >>> 0) || 1;
|
||
return function () {
|
||
s |= 0; s = (s + 0x6D2B79F5) | 0;
|
||
var t = Math.imul(s ^ (s >>> 15), 1 | s);
|
||
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
|
||
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
|
||
};
|
||
}
|
||
function randInt(rng, lo, hi) { return lo + Math.floor(rng() * (hi - lo + 1)); }
|
||
|
||
/* ── Кэш компиляции выражений (рендеренные строки часто повторяются) ── */
|
||
var _cache = Object.create(null);
|
||
function compileExpr(src) {
|
||
var key = String(src);
|
||
var c = _cache[key];
|
||
if (!c) { c = SE().compile(key); _cache[key] = c; }
|
||
return c;
|
||
}
|
||
function evalExpr(src, env) { return compileExpr(src).fn(env); }
|
||
|
||
function truthy(v) { return typeof v === 'number' && isFinite(v) && v !== 0; }
|
||
function isIntApprox(v) { return isFinite(v) && Math.abs(v - Math.round(v)) < 1e-9; }
|
||
|
||
function fmtNum(v) {
|
||
if (typeof v !== 'number') return String(v);
|
||
if (isIntApprox(v)) return String(Math.round(v));
|
||
return String(Math.round(v * 1e6) / 1e6);
|
||
}
|
||
|
||
/* Подстановка {name} -> значение (для выражений и подписей). */
|
||
function render(tpl, vals) {
|
||
return String(tpl).replace(/\{(\w+)\}/g, function (m, k) {
|
||
return Object.prototype.hasOwnProperty.call(vals, k) ? fmtNum(vals[k]) : m;
|
||
});
|
||
}
|
||
|
||
/* Лёгкая косметика ТОЛЬКО для показа (не для вычислений):
|
||
5*x -> 5x, «+ -» -> «− », ведущий коэффициент 1 у x убираем. */
|
||
function prettyMath(s) {
|
||
return String(s)
|
||
.replace(/(\d)\s*\*\s*(\d)/g, '$1·$2') // 4*5 -> 4·5 (число·число)
|
||
.replace(/\s*\*\s*/g, '') // 7*x -> 7x (неявное умножение)
|
||
.replace(/\+\s*-\s*/g, '− ') // + -3 -> − 3
|
||
.replace(/-\s*-\s*/g, '+ ')
|
||
.replace(/(^|[(=+\-\s])1(?=x)/g, '$1'); // ведущий 1·x -> x
|
||
}
|
||
|
||
function assign(base, extra) {
|
||
var o = {}, k;
|
||
for (k in base) if (Object.prototype.hasOwnProperty.call(base, k)) o[k] = base[k];
|
||
for (k in extra) if (Object.prototype.hasOwnProperty.call(extra, k)) o[k] = extra[k];
|
||
return o;
|
||
}
|
||
|
||
/* ── Выражение -> LaTeX (через AST SimExpr) для KaTeX-рендера ──
|
||
Возвращает строку LaTeX или null, если выражение не разобралось. Покрывает
|
||
наши нужды: дроби (\frac), степени, неявное умножение, скобки по приоритету,
|
||
сравнения (= ≠ ≤ ≥), sqrt/abs/тригонометрию. Один проход AST, без eval.
|
||
Reusable: тем же конвертером можно рендерить и задачи Уровня-1 (LLM). */
|
||
function _prec(n) {
|
||
if (!n) return 9;
|
||
if (n.k === 'cmp' || n.k === 'logic') return 0;
|
||
if (n.k === 'bin') {
|
||
if (n.op === '+' || n.op === '-') return 1;
|
||
if (n.op === '*' || n.op === '/' || n.op === '%') return 2;
|
||
if (n.op === '^') return 4;
|
||
}
|
||
if (n.k === 'un' || n.k === 'not') return 3;
|
||
return 5;
|
||
}
|
||
function _isNeg(n) { return (n.k === 'num' && n.v < 0) || (n.k === 'un' && n.op === '-'); }
|
||
function _negate(n) { return n.k === 'num' ? { k: 'num', v: -n.v } : n.a; }
|
||
function _wrapL(node, minPrec) {
|
||
var s = _latex(node);
|
||
return _prec(node) < minPrec ? '\\left(' + s + '\\right)' : s;
|
||
}
|
||
// Операнд умножения: отрицательное/унарное/сумму берём в скобки, иначе
|
||
// соседство схлопнет смысл (7*(-5) -> «7-5», 6*(x+1) -> «6x+1»).
|
||
function _mulOperand(node) {
|
||
if (_isNeg(node) || _prec(node) < 2) return '\\left(' + _latex(node) + '\\right)';
|
||
return _latex(node);
|
||
}
|
||
function _latex(node) {
|
||
switch (node.k) {
|
||
case 'num': return fmtNum(node.v);
|
||
case 'const':
|
||
if (node.v === Math.PI) return '\\pi';
|
||
if (node.v === Math.PI * 2) return '\\tau';
|
||
if (node.v === Math.E) return 'e';
|
||
return fmtNum(node.v);
|
||
case 'var': return node.name;
|
||
case 'un': return '-' + _wrapL(node.a, 3);
|
||
case 'not': return '\\lnot ' + _wrapL(node.a, 3);
|
||
case 'cmp': {
|
||
var m = { '==': '=', '!=': '\\ne', '<': '<', '<=': '\\le', '>': '>', '>=': '\\ge' };
|
||
return _latex(node.a) + ' ' + (m[node.op] || node.op) + ' ' + _latex(node.b);
|
||
}
|
||
case 'logic':
|
||
return _latex(node.a) + (node.op === '&&' ? ' \\land ' : ' \\lor ') + _latex(node.b);
|
||
case 'cond':
|
||
return _wrapL(node.c, 1) + ' \\,?\\, ' + _latex(node.a) + ' : ' + _latex(node.b);
|
||
case 'call': {
|
||
if (node.name === 'sqrt') return '\\sqrt{' + _latex(node.args[0]) + '}';
|
||
if (node.name === 'abs') return '\\left|' + _latex(node.args[0]) + '\\right|';
|
||
var TRIG = { sin: '\\sin', cos: '\\cos', tan: '\\tan', tg: '\\tan', ln: '\\ln', log: '\\log', exp: '\\exp' };
|
||
var fn = TRIG[node.name] || ('\\operatorname{' + node.name + '}');
|
||
return fn + '\\left(' + node.args.map(_latex).join(',\\, ') + '\\right)';
|
||
}
|
||
case 'bin': {
|
||
var op = node.op;
|
||
if (op === '/') return '\\frac{' + _latex(node.a) + '}{' + _latex(node.b) + '}';
|
||
if (op === '^') {
|
||
var base = _prec(node.a) < 5 ? '\\left(' + _latex(node.a) + '\\right)' : _latex(node.a);
|
||
return base + '^{' + _latex(node.b) + '}';
|
||
}
|
||
if (op === '*') {
|
||
var sep = (node.b.k === 'num' && node.b.v >= 0) ? ' \\cdot ' : ''; // знак · между числами; иначе соседство
|
||
return _mulOperand(node.a) + sep + _mulOperand(node.b);
|
||
}
|
||
if (op === '%') return _wrapL(node.a, 2) + ' \\bmod ' + _wrapL(node.b, 3);
|
||
// + или - (схлопываем a + (-b) -> a - b)
|
||
var right = node.b, rop = op;
|
||
if (op === '+' && _isNeg(right)) { rop = '-'; right = _negate(right); }
|
||
return _wrapL(node.a, 1) + ' ' + rop + ' ' + _wrapL(right, rop === '-' ? 2 : 1);
|
||
}
|
||
}
|
||
return '';
|
||
}
|
||
function exprToLatex(src) {
|
||
var ast;
|
||
try { ast = SE().parse(String(src)); } catch (e) { return null; }
|
||
try { return _latex(ast); } catch (e2) { return null; }
|
||
}
|
||
|
||
/* ── Подстановочная верификация корня ──
|
||
Истинно, если левая и правая части совпадают при answerVar = value. */
|
||
function verifyRoot(problem, value) {
|
||
var env = {};
|
||
env[problem.answerVar || 'x'] = value;
|
||
var L = evalExpr(problem.lhsExpr, env);
|
||
var R = evalExpr(problem.rhsExpr, env);
|
||
var residual = Math.abs(L - R);
|
||
var scale = Math.max(1, Math.abs(L), Math.abs(R));
|
||
return { ok: residual <= EPS * scale, residual: residual, lhs: L, rhs: R };
|
||
}
|
||
|
||
/* ── Материализация одного экземпляра ──
|
||
Возвращает problem или null, если за maxTries не удалось выполнить
|
||
ограничения / целочисленность / самопроверку. */
|
||
function instantiate(gen, opts) {
|
||
opts = opts || {};
|
||
var rng = opts.rng || makeRng(opts.seed != null ? opts.seed : 1);
|
||
var maxTries = opts.maxTries || 300;
|
||
var answerVar = gen.answerVar || 'x';
|
||
|
||
for (var attempt = 0; attempt < maxTries; attempt++) {
|
||
var env = {};
|
||
var pk = gen.pick || {}, k;
|
||
for (k in pk) if (Object.prototype.hasOwnProperty.call(pk, k)) {
|
||
env[k] = randInt(rng, pk[k][0], pk[k][1]);
|
||
}
|
||
|
||
if (gen.constraint && !truthy(evalExpr(gen.constraint, env))) continue;
|
||
|
||
if (gen.derive) {
|
||
for (k in gen.derive) if (Object.prototype.hasOwnProperty.call(gen.derive, k)) {
|
||
env[k] = evalExpr(gen.derive[k], env);
|
||
}
|
||
}
|
||
|
||
if (gen.require && !truthy(evalExpr(gen.require, env))) continue;
|
||
|
||
var answer = evalExpr(gen.answer, env);
|
||
if (gen.integerAnswer) {
|
||
if (!isIntApprox(answer)) continue;
|
||
answer = Math.round(answer);
|
||
}
|
||
|
||
var lhsExpr = render(gen.lhs, env);
|
||
var rhsExpr = render(gen.rhs, env);
|
||
var sEnv = assign(env, { ans: answer });
|
||
// compute-задача (проценты): показываем текстовый prompt из display, а
|
||
// уравнение lhs=rhs служит лишь для проверки → latex уравнения не строим.
|
||
var isCompute = gen.kind === 'compute';
|
||
var ll = isCompute ? null : exprToLatex(lhsExpr);
|
||
var rl = isCompute ? null : exprToLatex(rhsExpr);
|
||
|
||
var problem = {
|
||
genId: gen.id,
|
||
skill: gen.skill || gen.id, // ключ прогресса = id генератора, если skill не задан
|
||
title: gen.title,
|
||
kind: gen.kind || 'solve',
|
||
lhsExpr: lhsExpr,
|
||
rhsExpr: rhsExpr,
|
||
display: prettyMath(render(gen.display || (gen.lhs + ' = ' + gen.rhs), env)),
|
||
latex: (ll != null && rl != null) ? (ll + ' = ' + rl) : null,
|
||
answerVar: answerVar,
|
||
answer: answer,
|
||
params: env,
|
||
// шаг решения -> { note(текст), tex(подпись), latex(для KaTeX, null если не разобрался) }
|
||
// строковый шаг (легаси) трактуется как чистая заметка без формулы.
|
||
solution: (gen.solution || []).map(function (st) {
|
||
if (typeof st === 'string') return { note: render(st, sEnv), tex: '', latex: null };
|
||
var texSrc = st.tex ? render(st.tex, sEnv) : '';
|
||
return {
|
||
note: st.note ? render(st.note, sEnv) : '',
|
||
tex: texSrc ? prettyMath(texSrc) : '',
|
||
latex: texSrc ? exprToLatex(texSrc) : null
|
||
};
|
||
})
|
||
};
|
||
|
||
// Самопроверка: эталонный корень ОБЯЗАН удовлетворять уравнению.
|
||
var v = verifyRoot(problem, answer);
|
||
if (!v.ok) {
|
||
if (opts.strict) {
|
||
throw new Error('Генератор «' + gen.id + '»: корень ' + fmtNum(answer) +
|
||
' не удовлетворяет уравнению (невязка ' + v.residual + ').');
|
||
}
|
||
continue;
|
||
}
|
||
return problem;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/* ── Пакет из n различных по виду задач ── */
|
||
function generateBatch(gen, n, opts) {
|
||
opts = opts || {};
|
||
var rng = opts.rng || makeRng(opts.seed != null ? opts.seed : 1);
|
||
var out = [], seen = Object.create(null);
|
||
var guard = n * 20 + 50;
|
||
while (out.length < n && guard-- > 0) {
|
||
var p = instantiate(gen, { rng: rng, strict: opts.strict, maxTries: opts.maxTries });
|
||
if (!p) break;
|
||
if (seen[p.display]) continue;
|
||
seen[p.display] = 1;
|
||
out.push(p);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
/* ── Проверка ответа ученика ──
|
||
Принимает строку/число. SimExpr.compile сам срезает ведущее «x=», поэтому
|
||
"x = 5", "5", "10/2", "2+3" нормализуются к числу. Верно, если значение
|
||
удовлетворяет уравнению (эквивалентные формы проходят) ИЛИ совпадает с
|
||
эталонным корнем (страховка единственности для будущих многокорневых типов). */
|
||
function checkStudentAnswer(problem, input) {
|
||
var raw = String(input == null ? '' : input).trim();
|
||
if (!raw) return { ok: false, reason: 'empty', value: null, residual: null, message: 'Введите ответ.' };
|
||
|
||
var c = SE().compile(raw);
|
||
if (c.error) {
|
||
return { ok: false, reason: 'parse', value: null, residual: null,
|
||
message: 'Не понял ответ: ' + c.error };
|
||
}
|
||
var val = c.fn({});
|
||
if (!isFinite(val)) {
|
||
return { ok: false, reason: 'nan', value: val, residual: null, message: 'Это не число.' };
|
||
}
|
||
|
||
var v = verifyRoot(problem, val);
|
||
var nearCanonical = Math.abs(val - problem.answer) <= 1e-6 * Math.max(1, Math.abs(problem.answer));
|
||
var ok = v.ok || nearCanonical;
|
||
return {
|
||
ok: ok, reason: ok ? null : 'wrong', value: val, residual: v.residual,
|
||
message: ok ? 'Верно!' : 'Пока неверно.'
|
||
};
|
||
}
|
||
|
||
global.TrainerEngine = {
|
||
instantiate: instantiate,
|
||
generateBatch: generateBatch,
|
||
verifyRoot: verifyRoot,
|
||
checkStudentAnswer: checkStudentAnswer,
|
||
makeRng: makeRng,
|
||
// мелочи наружу для билдера/тестов
|
||
render: render,
|
||
prettyMath: prettyMath,
|
||
exprToLatex: exprToLatex
|
||
};
|
||
|
||
})(typeof window !== 'undefined' ? window : globalThis);
|