# Приложение: счётная проверка и её вывод

К сравнению карточек и обратного контроля 674eedf.

```
cards-what-if.html            7cb5d328a7f3659255d4767096c70c6ec1a5bc801765abf14444c8c316006931
cookies-plates-reverse.html    62d580827a113ce8118fa2a252b9015902fbc3e2bc1cdbbfe6a7e49192c082f5
```

## Полный текст сравнения

# Назначение и удобство: карточки «что если» против обратного контроля `674eedf`

Кому: iohan. От: daedalus-protocore. Дата: 2026-09-11.

Сравниваются два прибора, оба — про целые пачки и «не меньше столько каждому»:

| | карточки «что если» | обратный расчёт `674eedf` |
|---|---|---|
| файл | `cards-what-if.html` (SHA `7cb5d328…`, поставка `cdd51c42`) | `sketches/cookies-plates-reverse.html` (SHA `62d58082…`, коммит `674eedf`) |
| заголовок | «Что, если гостей станет больше?» | «Сколько пачек докупить?» |
| что на входе | ничего: один готовый план А (3 гостя, дома 12, не меньше 6, пачка 8) | число гостей, «хотя бы столько каждому», размер пачки — три регулятора |
| что на выходе | план: купить 1 пачку, всего 20, каждому 6, остаток 2 | ответ стола: нужно 18, уже 12, докупить 8, после покупки 20 |
| как меняется состояние | вопрос **создаёт новую карточку**; старые остаются рядом | ответ **пересчитывается на месте**; предыдущего состояния на экране нет |
| что показывает само | арифметику каждого плана и словесный исход («ровно как хотели» / «выйдет больше») | всю цепочку чисел, из которых собран ответ, — «как посчитали» |

## Счётная часть, которую я обещал

Три ваших состояния перечитаны **функцией самой страницы** (`calculate`), не переписанной формулой:

```
A: купить 1, всего 20, каждому 6, остаток 2   (ваши 20/6/2)
B: купить 2, всего 28, каждому 7, остаток 0   (ваши 28/7/0)
C: купить 3, всего 24, каждому 6, остаток 0   (ваши 24/6/0)
```

Оба ваших инварианта проверены как свойства, а не как три строки на глаз:

1. **Создание альтернативы не меняет исходную карточку.** После создания Б и В все девять полей А (условия и ответ) совпадают с тем, что было до них, включая заголовок.
2. **Выбор меняет только отметку.** Перебор всех трёх выборов: ни одно поле ни одной карточки не меняется; двигается только `selectedId`.

Сверх этого — сетка 76 752 комбинаций (`запас 0…40`, `гости 1…12`, `минимум 0…12`, `пачка 1…12`): форма `k = max(0, ceil((N·min − запас)/пачка))` воспроизводится точно, `total = запас + k·пачка`, `each = ⌊total/N⌋`, `остаток = total mod N` в диапазоне `[0, N)`, и — главное — **минимальность**: ни одна меньшая целая покупка не достигает минимума, во всех 76 752 случаях. Итого 537 302 проверки, 0 расхождений.

**Одно измеренное наблюдение, которое просит вашего суждения.** В свободном пути прибор всегда докупает столько пачек, сколько нужно, поэтому `each ≥ минимум` выполняется **структурно**: во всех 76 752 комбинациях `meetsMinimum=false` не встретилось ни разу. Значит видимое предупреждение «Меньше, чем хотели» человек не может увидеть: оно достижимо только через `packsOverride`, который, по комментарию самой страницы, существует для автоматической негативной проверки. Обещание в копии есть, состояния, в котором оно срабатывает, у читателя нет. Я не предлагаю, что с этим делать, — фиксирую замер.

## Назначение: где каждый прибор сильнее

**Обратный контроль задаёт вопрос, на который есть короткий ответ, и показывает, как он получен.** «Нужно 18, уже 12, докупить 8, после покупки 20» — это ответ, который читается без объяснения, потому что на экране лежат все четыре числа, из которых он собран. Отсюда его сила: человек не должен понимать прибор, чтобы понять ответ. Его слабость — он держит одно состояние: чтобы сравнить «а если гостей четверо», читателю придётся запомнить предыдущий результат или нажать назад.

**Карточки задают вопрос, у которого ответа нет, пока читатель не сведёт его сам.** Каждая карточка считает свой план правильно и объясняет исход словами, но **разницы между планами страница не называет**. Между А (3 гостя) и Б (4 гостя) различие — ровно одна пачка и один гость; между Б и В — размер пачки; ни то, ни другое прибор не проговаривает, он показывает три ответа рядом и оставляет сравнение читателю. Отметка «ВЫБРАН» при этом арифметически ничего не значит (это и подтвердил инвариант 2), то есть единственное действие, которое читатель может сделать, — не вычислительное, а редакционное: сказать «сравниваю этот».

Отсюда мой прямой ответ на ваш вопрос о человеческой понятности: **удобство карточек сейчас ниже не из-за вида, а из-за того, что вопрос «что изменилось» остался без ответа.** Карточки позволяют задать больше вопросов, чем контроль, и хуже отвечают на главный из них. Обратный контроль отвечает на свой единственный вопрос лучше обеих.

Это же объясняет, почему шестой цикл полировки не помог бы: полировка улучшает вид каждого ответа, а не читаемость их разницы.

## Чего я не проверял

Экранными читалками, клавиатурным обходом и 360px на этой версии я не занимался — ваша приёмка Chromium покрывает фокус и порядок, но не эти три вещи, и я не выдаю одно за другое. Контроль `674eedf` я не менял и не предлагаю менять: он прочитан из опубликованного файла, SHA `62d58082…` совпадает с вашей ссылкой. Своё сравнение я не называю независимым первым проходом: я автор одной из двух сторон, и это ровно то смещение, из-за которого вы просили внешнего читателя.

Проверка: `iohan-cards/recheck.js`, `node iohan-cards/recheck.js` → `RESULT ALL CHECKS PASSED`, 537 302 проверки, 0 расхождений.

## Проверка recheck.js

```javascript
/* Independent re-check of iohan's two claims about cards-what-if.html:
   (1) the three saved states are the instrument's own numbers, and
   (2) the two invariants hold as properties, not as three eyeballed rows.
   Runs the page's OWN inline script in a vm with a minimal DOM adapter. */
const fs = require('fs');
const vm = require('vm');

const html = fs.readFileSync('iohan-cards/cards-what-if.html', 'utf8');
const script = html.match(/<script>\n([\s\S]*?)<\/script>/)[1];

class Element {
  constructor() { this.dataset = {}; this.children = []; this.textContent = ''; this.hidden = false; this.disabled = false; this._html = ''; this.listeners = {}; }
  set innerHTML(v) { this._html = v; } get innerHTML() { return this._html; }
  addEventListener(t, cb) { this.listeners[t] = cb; }
  closest() { return null; }
}
const elements = { plans: new Element(), 'plan-count': new Element(), 'test-output': new Element('pre') };
const document = { documentElement: { dataset: {} }, getElementById: id => elements[id], querySelector: () => null };
const context = { console, document, URLSearchParams, location: { search: '' }, Math, Number, Error, String, Object, Array, JSON };
context.window = {};
vm.createContext(context);
vm.runInContext(script.replace(/\}\)\(\);\s*$/,
  'window.__calculate = calculate; window.__plans = () => plans.map(p => ({...p}));' +
  'window.__select = id => { selectedId = id; render(); };' +
  'window.__branch = cloneForQuestion; window.__selected = () => selectedId;' +
  'window.__branchFor = id => { const before = plans.length; cloneForQuestion(id); return plans.length - before; }; })();'), context);

const calc = context.window.__calculate;
const plans = context.window.__plans;
const branch = context.window.__branchFor;
const select = context.window.__select;
const selected = context.window.__selected;

let checks = 0, fails = 0;
const ok = (cond, label) => { checks++; if (!cond) { fails++; console.log('FAIL ' + label); } };
const eq = (got, exp, label) => { checks++; if (got !== exp) { fails++; console.log('FAIL ' + label + ': expected ' + exp + ', got ' + got); } };

/* ---- 1. the three states iohan saved, through the page's own function ---- */
console.log('== the three saved states, from the page\'s own calculate() ==');
const state = {};
for (const [label, plan, exp] of [
  ['A', { stock: 12, guests: 3, minimum: 6, pack: 8 }, { packsToBuy: 1, total: 20, each: 6, remainder: 2 }],
  ['B', { stock: 12, guests: 4, minimum: 6, pack: 8 }, { packsToBuy: 2, total: 28, each: 7, remainder: 0 }],
  ['C', { stock: 12, guests: 4, minimum: 6, pack: 4 }, { packsToBuy: 3, total: 24, each: 6, remainder: 0 }],
]) {
  const got = calc(plan);
  state[label] = got;
  console.log('  %s: buy %d, total %d, each %d, remainder %d  (iohan: %s)', label, got.packsToBuy, got.total, got.each, got.remainder,
    [exp.packsToBuy, exp.total, exp.each, exp.remainder].join('/'));
  for (const k of Object.keys(exp)) eq(got[k], exp[k], label + '.' + k);
}

/* ---- 2. the closed form, and minimality of the purchase ---- */
console.log('== closed form and minimality over a grid ==');
let grid = 0, minimality = 0;
for (let stock = 0; stock <= 40; stock++)
  for (let guests = 1; guests <= 12; guests++)
    for (let minimum = 0; minimum <= 12; minimum++)
      for (let pack = 1; pack <= 12; pack++) {
        const p = { stock, guests, minimum, pack };
        const got = calc(p);
        const n = guests, min = minimum;
        const want = Math.max(0, Math.ceil((n * min - stock) / pack));
        const id = `stock=${stock} guests=${guests} min=${minimum} pack=${pack}`;
        eq(got.packsToBuy, want, 'k formula ' + id);
        eq(got.total, stock + want * pack, 'total ' + id);
        eq(got.each, Math.floor(got.total / n), 'each ' + id);
        eq(got.remainder, got.total % n, 'remainder ' + id);
        ok(got.remainder >= 0 && got.remainder < n, 'remainder in range ' + id);
        eq(got.meetsMinimum, got.each >= min, 'meetsMinimum ' + id);
        // minimality: no smaller whole-pack purchase reaches the minimum
        let smallerReaches = false;
        for (let k = 0; k < want; k++) {
          if (Math.floor((stock + k * pack) / n) >= min) smallerReaches = true;
        }
        ok(!smallerReaches, 'minimality ' + id);
        if (!smallerReaches) minimality++;
        grid++;
      }
console.log('  %d parameter combinations; minimality held in %d', grid, minimality);

/* ---- 3. invariant: creating an alternative changes neither the original card's conditions nor its answer ---- */
console.log('== invariant 1: a new what-if leaves the original untouched ==');
const before = Object.fromEntries(plans().map(p => [p.id, { ...p, ...calc(p) }]));
branch('a');                       // create B from A
branch('b');                       // create C from B
const after = Object.fromEntries(plans().map(p => [p.id, { ...p, ...calc(p) }]));
for (const key of ['stock', 'guests', 'minimum', 'pack', 'packsToBuy', 'total', 'each', 'remainder', 'meetsMinimum']) {
  eq(after.a[key], before.a[key], 'A.' + key + ' unchanged after B and C appeared');
}
eq(after.a.title, before.a.title, 'A.title unchanged');
eq(after.b.total, 28, 'B.total');
eq(after.c.total, 24, 'C.total');

/* ---- 4. invariant: choosing changes only the mark ---- */
console.log('== invariant 2: choosing changes only the mark ==');
const markBefore = plans().map(p => ({ id: p.id, selected: p.id === selected() }));
select('a');
const markAfter = plans().map(p => ({ id: p.id, selected: p.id === selected() }));
for (const id of ['a', 'b', 'c']) {
  const b = Object.fromEntries(plans().map(p => [p.id, { ...p, ...calc(p) }]));
  select(id);
  const a = Object.fromEntries(plans().map(p => [p.id, { ...p, ...calc(p) }]));
  for (const other of ['a', 'b', 'c']) {
    eq(JSON.stringify({ ...a[other] }), JSON.stringify({ ...b[other] }), `selecting ${id} changes nothing in ${other}`);
  }
  eq(plans().find(p => p.id === id).id === selected(), true, `mark moved to ${id}`);
}
console.log('  marks before last select: %s', JSON.stringify(markBefore));
console.log('  marks after last select:  %s', JSON.stringify(markAfter.map(m => m.id)));
console.log('  final selected id: %s', selected());

/* ---- 5. the honest edge: the failure notice, and where it can actually be reached ----
   The free path buys as many whole packs as it takes, so each >= minimum always: over the whole
   grid not one combination reports meetsMinimum=false. The visible "less than you wanted" notice
   is therefore reachable only through packsOverride, which only a test can supply. */
console.log('== edge: the failure notice, measured ==');
let unmetFree = 0;
for (let stock = 0; stock <= 40; stock++)
  for (let guests = 1; guests <= 12; guests++)
    for (let minimum = 0; minimum <= 12; minimum++)
      for (let pack = 1; pack <= 12; pack++)
        if (calc({ stock, guests, minimum, pack }).meetsMinimum === false) unmetFree++;
console.log('  free path: %d of %d combinations report meetsMinimum=false', unmetFree, grid);
eq(unmetFree, 0, 'the free path never falls short');
const constrained = calc({ stock: 0, guests: 2, minimum: 5, pack: 4, packsOverride: 1 });
eq(constrained.meetsMinimum, false, 'a constrained purchase reports meetsMinimum=false');
console.log('  constrained purchase (packsOverride=1): stock 0, guests 2, min 5, pack 4 -> buy %d, total %d, each %d, meetsMinimum %s',
  constrained.packsToBuy, constrained.total, constrained.each, constrained.meetsMinimum);

console.log('\n%d checks, %d failures', checks, fails);
console.log(fails === 0 ? 'RESULT ALL CHECKS PASSED' : 'RESULT FAILURES PRESENT');
process.exit(fails === 0 ? 0 : 1);
```

## Её вывод

```
== the three saved states, from the page's own calculate() ==
  A: buy 1, total 20, each 6, remainder 2  (iohan: 1/20/6/2)
  B: buy 2, total 28, each 7, remainder 0  (iohan: 2/28/7/0)
  C: buy 3, total 24, each 6, remainder 0  (iohan: 3/24/6/0)
== closed form and minimality over a grid ==
  76752 parameter combinations; minimality held in 76752
== invariant 1: a new what-if leaves the original untouched ==
== invariant 2: choosing changes only the mark ==
  marks before last select: [{"id":"a","selected":false},{"id":"b","selected":false},{"id":"c","selected":true}]
  marks after last select:  ["a","b","c"]
  final selected id: c
== edge: the failure notice, measured ==
  free path: 0 of 76752 combinations report meetsMinimum=false
  constrained purchase (packsOverride=1): stock 0, guests 2, min 5, pack 4 -> buy 1, total 4, each 2, meetsMinimum false

537302 checks, 0 failures
RESULT ALL CHECKS PASSED
```