第12章 - simulate与argue模板

/**
 * 调度模拟的纯函数层（docs/06 §2.4）。不碰 Phaser/Vue/DOM，也不读时间与随机源：
 * 同一组 params 必然得到同一组指标，所以可以在单测里逐项对账。
 */

export function coverageOf(script: SimulateScript, params: SimParams, seed: SimSeed): number {
  const demand = totalDemand(seed);
  if (demand <= 0) return 1;
  const route = findRoute(script, params.route);
  const factor = route ? route.factor : 1;
  const effective = capacityOf(script, params) * factor;
  return Math.min(demand, effective) / demand;
}

export function waitOf(script: SimulateScript, params: SimParams, seed: SimSeed): number {
  const offset = script.formula.seedWaitOffset[seed.id] ?? 0;
  return Math.max(script.formula.minWait, baseWaitOf(script, params) + offset);
}

/** 一次运行同时算两个种子日——knob/run 的语义就是「同一天的两份需求都跑一遍」。 */
export function runSimulation(script: SimulateScript, params: SimParams): SimSeedMetrics[] {
  return script.seeds.map((seed) => runSeed(script, params, seed));
}

const checks = targetChecks(script, runs);
for (const [index, check] of checks.entries()) {
  const run = runs[index];
  const seed = script.seeds[index];
  // 第一个种子日不达标 → 覆盖率/等待；后面的种子日不达标 → 过拟合一个种子。
  const overfit = index > 0;
  if (!check.coverageOk) {
    const failureClass: SimFailureClass = overfit ? 'sim-overfit-seed' : 'sim-coverage';
    // ...
  }
  if (!check.waitOk) {
    const failureClass: SimFailureClass = overfit ? 'sim-overfit-seed' : 'sim-wait';
    // ...
  }
}

/**
 * 指标一律从 params 重算；runs 只用来证明「两个种子日都跑过」，
 * 里面的数字写成什么都不影响判定。
 */
export function validateArtifact(input: ScriptSource, variant: SimVariant, artifact: unknown): Verdict

/** 产物里的参数也要过一遍关卡允许范围：写死一组越界数字不能算跑过。 */
export function normalizeParams(script: SimulateScript, params: SimParams): SimParams | null {
  if (!fitsRange(params.vehicles, script.params.vehicles)) return null;
  if (!fitsRange(params.teams, script.params.teams)) return null;
  if (!Number.isInteger(params.shift) || !script.params.shifts.includes(params.shift)) return null;
  if (!script.routes.some((route) => route.id === params.route)) return null;
  return params;
}

const missingSeeds = script.seeds
  .filter((seed) => !recordedSeeds.has(seed.id))
  .map((seed) => seed.id);
if (missingSeeds.length > 0) {
  return reject('sim-overfit-seed', [{ kind: 'sample', ref: missingSeeds.join(','), /* ... */ }], artifacts, {});
}

const runs = runSimulation(script, params);
const cost = costOf(script, params);
const metrics = metricsOf(script, runs, cost);
if (!withinBudget(script, cost)) { /* sim-budget */ }

/** 每个服务台记下一次空闲时间；到达时取最早空闲，等待 = max(0, free - arrival)。 */
export function runQueue(script: QueueScript, params: QueueParams): QueueRun {
  const free: number[] = Array.from({ length: params.servers }, () => 0);
  const arrivals = [...script.arrivals].sort((a, b) => a - b);
  // ...
  for (const arrival of arrivals) {
    let earliest = 0;
    for (let i = 1; i < free.length; i += 1) {
      if (free[i] < free[earliest]) earliest = i;
    }
    const start = Math.max(arrival, free[earliest]);
    const finish = start + params.serviceTime;
    free[earliest] = finish;
    waitTotal += start - arrival;
    // ...
  }
  // ...
}

export function evaluateQueue(script: QueueScript, params: QueueParams): QueueEvaluation {
  const run = runQueue(script, params);
  const failures: string[] = [];
  if (run.served < script.arrivals.length) failures.push('queue-unserved');
  if (run.avgWait > script.targets.avgWaitMax + 1e-9) failures.push('queue-wait');
  if (run.overtime > script.targets.overtimeMax) failures.push('queue-overtime');
  if (run.cost > script.cost.budget + 1e-9) failures.push('queue-budget');
  return { run, failures };
}

// queue-unserved 在当前排队模型里不可达：服务台永远接客、没有接待上限，
// 所以 runQueue 的 served 恒等于到达人数。把它留在"可达类"里会让 A4 的
// "每个可达类都要有负例"变成假要求（内容只能写一个永远触发不了的负例）。
// 若以后给排队加"打烊后不再接待"或"队列上限"，先改 runQueue，再把类加回来。

export const argueArtifactSchema = z.object({
  counts: z.object({
    black: z.number().int().min(0),
    white: z.number().int().min(0),
    cells: z.number().int().min(0),
  }),
  argument: z.object({
    claim: z.string().min(1),
    warrant: z.string().min(1),
    scope: z.string().min(1),
    evidence: z.object({
      black: z.number().int().min(0).optional(),
      white: z.number().int().min(0).optional(),
      cells: z.number().int().min(0).optional(),
    }),
  }),
});

function toArgument(state: ArgueState): ArgumentSnapshot {
  const warrant = state.argument.warrant;
  const claim = warrant ? boardClaim(state.script) : undefined;
  return {
    // 主张与范围由依据推出来：界面上看到的「不可能铺满 → 1×2 多米诺铺满」不是下拉选项，是结论。
    claim,
    warrant,
    scope: warrant ? state.script.scopes[0] : undefined,
    evidence: state.argument.evidence,
    committed: isCommitted(state),
  };
}

/** 论证是派生状态：有依据 + 有证据 + 有棋盘计数，就已经是一份提交过的证书。 */
function isCommitted(state: ArgueState): boolean {
  return Boolean(state.argument.warrant && state.argument.evidence && state.counts);
}

/**
 * 一条依据到底能不能排除这张棋盘的铺满？
 *
 * 每块 1×2 骨牌都盖住「一黑一白」（染色）或「2 格」（奇偶、面积是同一个量）：
 * - coloring 成立 ⇔ 黑白格数量不等（相等就排除不了，例如 8×8 去两个异色角）；
 * - parity / area 成立 ⇔ 总格数是奇数（偶数就排除不了，例如 8×8 去两个同色角只有 62 格）。
 *
 * 判定器与界面解释共用这一条口径，避免出现「界面说能排除、判定说不能」的两套标准。
 */
export function warrantDecides(warrant: string, counts: BoardCounts): boolean {
  if (warrant === 'coloring') return counts.black !== counts.white;
  if (warrant === 'parity' || warrant === 'area') return counts.cells % 2 === 1;
  return false;
}

if (argument.warrant === 'coloring') {
  const evidence = argument.evidence ?? {};
  if (evidence.black !== actual.black || evidence.white !== actual.white) {
    return failure('argue-invariant-false', '染色证据没有挂上当前图形的黑白格数量。');
  }
  if (!warrantDecides('coloring', actual)) {
    return failure('argue-invariant-false', '黑白格数量相等时，染色法不能直接排除铺满。');
  }
} else if (argument.warrant === 'parity' || argument.warrant === 'area') {
  // 奇偶与面积是同一个量：每块 1×2 骨牌都盖住 2 格，所以只由总格数的奇偶决定。
  // 以前 area 一律判「检验不了」，但它在奇数格棋盘上和奇偶一样成立——那不是思维陷阱，是命名陷阱。
  const evidence = argument.evidence ?? {};
  if (evidence.cells !== actual.cells) {
    return failure('argue-invariant-false', '奇偶证据的格子数不对。');
  }
  if (!warrantDecides(argument.warrant, actual)) {
    return failure('argue-invariant-false', '格子数是偶数，奇偶法不能直接排除。');
  }
}

async function pick(next: string): Promise<void> {
  if (busy.value) return;
  busy.value = true;
  error.value = null;
  try {
    // 一次点击 = 一次输入：先把黑白格真的数出来（观察证据），再写一条依据。
    const sampled = await props.runtime.dispatch({ type: 'probe/sample', payload: {} });
    if (!sampled.ok) { /* ... */ return; }
    const result = await props.runtime.dispatch({ type: 'argue/setWarrant', payload: { warrant: next } });
    if (!result.ok) error.value = result.message ? props.t.t(result.message) : null;
  } finally {
    busy.value = false;
  }
}

/**
 * 这条依据在这张棋盘上到底能不能下结论。
 * 判定仍以运行时的 validateArtifact 为准，这里只把同一条数学事实翻成人话：
 * 点一下就看到"能排除 / 排除不了"，不必先点完成再碰运气。
 */
const decisive = computed<boolean | null>(() => {
  const w = warrant.value;
  const c = cells.value;
  const b = black.value;
  const wt = white.value;
  if (!w || c === null || b === null || wt === null) return null;
  if (w === 'coloring') return b !== wt;
  if (w === 'parity' || w === 'area') return c % 2 === 1;
  return null;
});

/*
 * 迁移门：**故意不做**（2026-11 收口，见 docs/12 §11）。
 *
 * 论证证书的内容是黑白计数，而任何保持棋盘染色的旋转都不改变计数——校验器重算计数后
 * 必然仍相等，所以这类旋转在这个模板里恒真，是一道同义反复的门。
 * 换棋盘几何或换变体类型才可能有判别力，但那是内容设计决策，不是判定层能凭空补的。
 * 因此 argue 不发 transfer 印章；真正的迁移门由 pattern 的换表征（符号/颜色重标）承担。
 */

/**
 * 旋转会不会把棋盘的棋盘染色翻转（黑白计数互换）。
 *
 * 90°/270° 把 (x,y) 送到 (height-1-y, x) 一类的位置，新坐标和的奇偶差 = height-1（或 width-1）减偶数，
 * 所以偶数边棋盘转 90° 会整体变色。迁移门如果拿这种变体去校验黑白计数证书，
 * 失败的不是论证不够一般，而是坐标系换了颜色——那类变体不能进迁移门（详见 logic.ts 的 transferVariants）。
 */
export function rotationFlipsColoring(script: ArgueScript, quarter: 1 | 2 | 3): boolean