code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ulw-research
ulw-research
UnverifiedRuns maximum-saturation research with a cooperating team, claim-graph gating, and a cited, QA'd deliverable. Use when the user explicitly asks for research or a deep investigation, including any 'ulw' research wording.
scripts/fact-unit-dimensions-2.test.ts
View on GitHubimport { expect, test } from "bun:test"
import { recompute } from "./fact-derive.mjs"
import { derive } from "./tests/derive-clock"
import { addRow, emptyLedger, retractRow, validateLedger } from "./fact-ledger.mjs"
import { canonicalUnit } from "./unit-rules.mjs"
import { convertFactor } from "./units.mjs"
import { Row, Book, now, book, row, sum, refused } from "./tests/fact-unit-dimensions-support"
test("dimension 21: expression root and literal precision remain explicit", () => {
const l = book(["1000", "3"], ["m", "m"])
expect(row(l, { op: "expr", formula: "F1 - F2", unit: "m" }).value).toBe("997")
expect(row(l, { op: "expr", formula: "(F1 - F2) * 1", unit: "m" }).value).toBe("1000")
expect(row(l, { op: "expr", formula: "(F1 - F2) * 1.00", unit: "m" }).value).toBe("1000")
})
test("dimension 22: cloned snapshots are deterministic and replay appends a new identity", () => {
const original = book()
const left = structuredClone(original)
const right = structuredClone(original)
expect(row(left, sum)).toEqual(row(right, sum))
expect(row(left, sum).fact_id).toBe("F4")
expect(original.rows).toHaveLength(2)
})
test("dimension 23: coherent trusted input rewrites are a documented arithmetic limitation", () => {
const l = book(["0", "3"])
const km = row(l, { op: "convert", operands: ["F1"], to: "km" })
const cm = row(l, { op: "convert", operands: ["F1"], to: "cm" })
const coherent = { ...cm, fact_id: km.fact_id, label: km.label }
expect(recompute(l, coherent).ok).toBe(true)
expect(recompute(l, { ...km, unit: "cm" }).ok).toBe(false)
})
test("dimension 24: sum permutation and ordered arithmetic keep their own semantics", () => {
const l = book(["2", "5"])
for (const operands of [
["F1", "F2"],
["F2", "F1"],
])
expect(row(l, { ...sum, operands }).exact).toEqual({ num: "7", den: "1" })
expect(row(l, { ...sum, op: "diff" }).exact).toEqual({ num: "-3", den: "1" })
expect(row(l, { ...sum, op: "diff", operands: ["F2", "F1"] }).exact).toEqual({ num: "3", den: "1" })
})
test("dimension 25: numeric domain boundaries do not forbid negative ordinary arithmetic", () => {
for (const values of [
["6", "5"],
["-1", "5"],
["0", "0"],
])
expect(derive(book(values), { op: "share", part: "F1", whole: "F2", unit: "%" }).error).toBeDefined()
expect(row(book(["-2", "-5"]), sum).exact).toEqual({ num: "-7", den: "1" })
expect(derive(book(), { op: "expr", formula: "F1 / (F2 - F2)", unit: null }).error).toBeDefined()
})
test("dimension 26: percent products and pct nodes preserve fraction semantics", () => {
const l = book(["20", "50"], ["%", "%"])
expect(row(l, { op: "expr", formula: "pct(F1 * F2)", unit: "%" }).exact).toEqual({ num: "10", den: "1" })
expect(row(l, { op: "diff", operands: ["F2", "F1"], unit: "%p" }).exact).toEqual({ num: "30", den: "1" })
expect(derive(l, { op: "expr", formula: "pct(F1)", unit: "%" }).error).toBeDefined()
})
test("dimension 27: conversion maps compose with exact independent rational arithmetic", () => {
const groups = [
["mm", "cm", "m", "km"],
["g", "kg", "t"],
["ms", "s", "min", "h"],
["B", "KB", "MB", "GB", "TB"],
["C", "F"],
["%", "\u2030"],
["KRW", "KRW-e3", "KRW-e4", "KRW-e8", "KRW-e12"],
]
const apply = (
factor: { num: bigint; den: bigint; offset?: { num: bigint; den: bigint } } | null,
x: [bigint, bigint],
): [bigint, bigint] => {
if (!factor) throw Error("missing conversion")
const o = factor.offset ?? { num: 0n, den: 1n }
return [x[0] * factor.num * o.den + o.num * x[1] * factor.den, x[1] * factor.den * o.den]
}
for (const group of groups)
for (const a of group)
for (const b of group)
for (const c of group) {
for (const value of [-3n, 0n, 7n]) {
const direct = apply(convertFactor(a, c), [value, 1n])
const chained = apply(convertFactor(b, c), apply(convertFactor(a, b), [value, 1n]))
expect(direct[0] * chained[1]).toBe(chained[0] * direct[1])
}
}
expect(derive(book(), { op: "convert", operands: ["F1"], to: "furlong" }).error).toBeDefined()
})
test("dimension 28: grammar rejects injection and preserves precedence", () => {
for (const formula of ["F1;globalThis.x=1", "-F1", "F1 ** 2", "pct F1", "(F1", "F1 F2"])
expect(derive(book(), { op: "expr", formula, unit: "m" }).error).toBeDefined()
expect(row(book(), { op: "expr", formula: "F1 + F2 * 2", unit: "m" }).exact).toEqual({ num: "7", den: "1" })
})
test("dimension 29: signed rounding ties and canonical display are exact", () => {
for (const [values, expected] of [
[["-1.25", "-2.5"], "-3.8"],
[["1.25", "2.5"], "3.8"],
[["999.5", "0"], "1000"],
] as const) {
expect(row(book([...values]), sum).value).toBe(expected)
}
const l = book(["20", "15"], ["%", "%"])
const delta = row(l, { op: "diff", operands: ["F1", "F2"], unit: "%p" })
expect(recompute(l, { ...delta, render: "5 pp" }).ok).toBe(false)
})
test("dimension 30: seeded factor trees have an independent arithmetic and unit oracle", () => {
let seed = 0x11009
const next = () => {
seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0
return seed
}
const atoms = ["m", "s", "person"]
for (let i = 0; i < 100; i++) {
const counts = [0, 0, 0]
const factors = Array.from({ length: 5 }, () => {
const index = next() % atoms.length
const exponent = (next() % 7) - 3
counts[index] += exponent
return `(${atoms[index]}^${exponent})`
})
const side = (positive: boolean) =>
atoms
.map((a, index) => ({ a, n: counts[index] }))
.filter(({ n }) => (positive ? n > 0 : n < 0))
.sort((a, b) => a.a.localeCompare(b.a))
.map(({ a, n }) => (Math.abs(n) === 1 ? a : `${a}^${Math.abs(n)}`))
const top = side(true).join("*") || "1"
const bottom = side(false)
const expectedUnit = bottom.length
? `${top}/${bottom.length === 1 ? bottom[0] : `(${bottom.join("*")})`}`
: top === "1"
? null
: top
expect(canonicalUnit(factors.join("*"))).toBe(expectedUnit)
const a = BigInt(1 + (next() % 100))
const b = BigInt(1 + (next() % 100))
const l = book([String(a), String(b)], [factors.join("*"), "person"])
const result = row(l, { op: "expr", formula: "F1 * F2 / F2", unit: expectedUnit })
expect(result.exact).toEqual({ num: String(a), den: "1" })
expect(result.unit).toBe(expectedUnit)
expect(recompute(l, result).ok).toBe(true)
expect(recompute(l, { ...result, exact: { num: String(a + 1n), den: "1" } }).ok).toBe(false)
}
})
test("dimension 30: independent rational oracle crosses every operation with metadata and tampering", () => {
let state = 3917
const next = () => {
state = (Math.imul(state, 1103515245) + 12345) >>> 0
return state
}
const exact = (n: bigint, d = 1n) => {
let a = n < 0n ? -n : n
let b = d
while (b) [a, b] = [b, a % b]
return { num: String(n / a), den: String(d / a) }
}
for (let i = 0; i < 50; i++) {
const a = BigInt(1 + (next() % 50))
const b = a + BigInt(1 + (next() % 50))
const meta = {
population: { country: "x", cohort: i },
accounting_basis: "cash",
snapshot_window: "2026",
entity: "acme",
}
const specs: Array<[Row, { num: string; den: string }]> = [
[{ ...sum }, exact(a + b)],
[{ ...sum, op: "diff" }, exact(a - b)],
[{ op: "ratio", num: "F1", den: "F2", unit: null }, exact(a, b)],
[{ op: "share", part: "F1", whole: "F2", unit: "%" }, exact(100n * a, b)],
[{ op: "growth", from: "F1", to: "F2", unit: "%" }, exact(100n * (b - a), a)],
[{ op: "convert", operands: ["F1"], to: "cm" }, exact(100n * a)],
[{ op: "expr", formula: "F1 * 2 / F2", unit: null }, exact(2n * a, b)],
]
for (const [spec, expected] of specs) {
const l = book(
[String(a), String(b)],
["metre", "m"],
[
{ ...meta, valid_at: "2025" },
{ ...meta, valid_at: "2026" },
],
)
const result = row(l, spec)
expect(result.exact).toEqual(expected)
expect(recompute(l, result).ok).toBe(true)
expect(recompute(l, { ...result, unit: "person" }).ok).toBe(false)
expect(recompute(l, { ...result, exact: { num: String(BigInt(expected.num) + 1n), den: expected.den } }).ok).toBe(
false,
)
}
const l = book([String(100n * a), String(b)], ["bp/person", "person"])
const result = row(l, { op: "expr", formula: "F1 * F2", unit: "%p" })
expect(result.exact).toEqual(exact(a * b))
}
})
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |