@lapxo/obligations 0.2.0 → 0.3.0

package/README.md

@@ -2,9 +2,9 @@
 
 # @lapxo/obligations
 
-![version 0.2.0](https://img.shields.io/badge/version-0.2.0-8c959f) ![license MIT](https://img.shields.io/badge/license-MIT-8c959f) ![node >=22.12](https://img.shields.io/badge/node-%3E%3D22.12-8c959f) ![dependencies 0](https://img.shields.io/badge/dependencies-0-2da44e) ![cases 178 hold](https://img.shields.io/badge/cases-178_hold-2da44e) ![verify agrees](https://img.shields.io/badge/verify-agrees-8c959f) [![DOI 10.5281/zenodo.21858428](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.21858428-8c959f)](https://doi.org/10.5281/zenodo.21858428)
+![version 0.3.0](https://img.shields.io/badge/version-0.3.0-8c959f) ![license MIT](https://img.shields.io/badge/license-MIT-8c959f) ![node >=22.12](https://img.shields.io/badge/node-%3E%3D22.12-8c959f) ![dependencies 0](https://img.shields.io/badge/dependencies-0-2da44e) ![cases 203 hold](https://img.shields.io/badge/cases-203_hold-2da44e) ![verify agrees](https://img.shields.io/badge/verify-agrees-8c959f) [![DOI 10.5281/zenodo.21858428](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.21858428-8c959f)](https://doi.org/10.5281/zenodo.21858428)
 
-The algebra of a cell: two poles, origins with phase, six operations.
+The algebra of a cell: two poles, origins with phase, eight acts.
 
 ## The idea
 
@@ -19,20 +19,23 @@ A cell is drawn as bars on one scale: a grey bar is what one origin claims, pote
 ## The object
 
 ```text
-c = ⟨⊥, ⊤, O, r, ⊑⟩        ⊥, ⊤ ∈ L with ≤     O = {(o, φ, s)}     r ∈ ℕ     ⊑ the order of rest
-meet(c)  = ⊤ ∧ ⋀_{o∈O} span_o
-info(c)  ⟺ |ext(O)| ≥ 2 ∧ meet(c) ≠ ∅
-F(c)     = log₂ |{x ∈ L : ⊥ ≤ x ≤ ⊤}|
-sign     : ⊤(c′) ← ⊤(c′) ∧ s   ∀ c′ ⊒ c
-join     : ⊤(c)  ← ⊤(c)  ∨ s   for c alone, witnessed
-state(c) ∈ {FREE, REQUIRED, FORBIDDEN, CONFLICT}
+c = ⟨⊥, ⊤, O, ⊑⟩        over L at r
+⊥(c)                   = ⋁ required ∨ ⋁_{o∈O} lo_o
+⊤(c)                   = ⋀ signed ∧ ⋀_{o∈O} hi_o
+info(c)                ⟺ |ext(O)| ≥ 2 ∧ meet(c) ≠ ∅
+F(C)                   = Σ_{c∈C} F(c),   F(a(c)) ≤ F(c) for every act a that narrows
+A(c)                   = |Σ_{o∈O} s_o w_o e^{iφ_o}|²
+⊤(c)                   = ⋀_{b ⊑ c} signed(b) ∧ ⋀_{o∈O} hi_o,   one line per act
+|e^{ia} + e^{ib}|² < 2 ⟺ |a − b| > π/2
+state(c)               ∈ {FREE, REQUIRED, FORBIDDEN, CONFLICT}
 ```
 
 ```text
-one origin                                       REQUIRED   ○
-two or more, they meet, within the ceiling       FREE       ●
-two or more, they meet, outside the ceiling      FORBIDDEN  ✕
-two or more, they do not meet                    CONFLICT   ⋔
+bounds that cross                        CONFLICT   ⋔
+one origin                               REQUIRED   ○
+claims that do not meet                  CONFLICT   ⋔
+claims that meet and fit the bounds      FREE       ●
+claims that meet outside the bounds      FORBIDDEN  ✕
 ```
 
 ## What holds
@@ -41,9 +44,9 @@ The theory of this package is ten axioms and what follows from them. Three of th
 
 A claim from one origin is potential; a cell is information only where two independent origins touch it and their intervals meet. That is encounter, and 28 lines of the lock rest on it.
 
-Every quantity has two poles, a floor that is required and a ceiling that is permitted, and a cell is the pair. That is carrier, and 17 lines of the lock rest on it.
+Two bounds on one cell fold by the meet of their form; the order they arrive in never decides. That is meet, and 19 lines of the lock rest on it.
 
-Two bounds on one cell fold by the meet of their form; the order they arrive in never decides. That is meet, and 13 lines of the lock rest on it.
+Every quantity has two poles, a floor that is required and a ceiling that is permitted, and a cell is the pair. That is carrier, and 17 lines of the lock rest on it.
 
 <details><summary>The other seven, each one line of the lock with a sample that shows it and one that would break it</summary>
 
@@ -134,36 +137,31 @@ Five readings:
 - **A distant signature moves a cell that did not move** — a hint, never a claim. *Breaks if one act is both local and non-local.*
 - **Amplitudes without an origin** — what is left of a cell when who, ceiling, resolution and band are dropped. *Breaks if the arithmetic forbids what the restored fields predict.*
 - **Measurement** — a thermometer, a survey, an interferometer and a headcount fill the same five fields. *Breaks if one instrument cannot.*
-- **The medium of encounters** — what carries an encounter is a medium, and a medium is what two origins can both reach. *Breaks if two origins meet with nothing they both reach.*
-- **Refereed game** — a field of cells with origins and signatures is a game whose referee is inside it. *Breaks if a player can suspend the rule that two origins are needed.*
+- **The medium of encounters** — what carries an encounter is a medium, and a medium is what two origins can both reach: in each instrument the medium can be named and the encounter happens where two origins touch it and nowhere else, so two origins at one cell make information and the same two at two cells make none; structural resemblance, one origin, not a claim about the world. *Breaks if two origins meet with nothing they both reach.*
+- **Refereed game** — a field of cells with origins and signatures is a game whose referee is inside it: a move is a claim, a claim alone is potential, two that meet are information, a signature moves every cell that rests on it, and no player may suspend the rule that makes the first four; the claim is that each of five readings of the field matches all five properties; structural resemblance, one origin, not a claim about the world. *Breaks if a player can suspend the rule that two origins are needed.*
 
 <details><summary>Every conjecture in full</summary>
 
-Resolution times independent encounters per cell stays above a floor c; the sufficient resolution is where the product saturates. It is falsified by a cell read at four resolutions whose product of resolution and independent encounters comes out above the floor while the encounters fall away with the sharpening. A product that rises as the reading sharpens would say the floor is not a floor but an accident of how coarsely the cell was read.
+Resolution times independent encounters per cell stays above a floor c; the sufficient resolution is where the product saturates. The falsifier: a cell read at four resolutions whose product of resolution and independent encounters comes out above the floor while the encounters fall away with the sharpening. A product that rises as the reading sharpens would say the floor is not a floor but an accident of how coarsely the cell was read.
 
-Where reading already is, the next reading lands: over eight epochs of placement in proportion to the origins a cell already carries, the ratio between the densest tenth and the sparsest rises at every epoch and the deserts stay empty, while the same budget placed blind to density holds that ratio near two and touches three times as many cells. It is falsified by encounters that land independently of the density already there. Then the ratio does not rise with the epochs and the cells touched grow with the budget, which is what the blind placement in the yes sample shows.
+Where reading already is, the next reading lands: over eight epochs of placement in proportion to the origins a cell already carries, the ratio between the densest tenth and the sparsest rises at every epoch and the deserts stay empty, while the same budget placed blind to density holds that ratio near two and touches three times as many cells. The falsifier: encounters that land independently of the density already there. Then the ratio does not rise with the epochs and the cells touched grow with the budget, which is what the blind placement in the yes sample shows.
 
-Stated as a hint and never as a claim about the world: if what is is a field of floors and ceilings, a distant signature changes a cell whose own record never moved, and in two hundred trials of one cell holding one value the verdict came out both ways, so nothing stored at the cell explains the difference and what explains it is the bound the cell rests on; the resemblance is structural and never arithmetic, with no continuous amplitudes and no inequality violated by number; structural resemblance, one origin, not a claim about the world. It is falsified by one act that is both local and non-local — a change that travels a distance and also reaches a cell that does not rest on its bound. The two poles would then be one, and this would be a claim about the world rather than a hint.
+Stated as a hint and never as a claim about the world: if what is is a field of floors and ceilings, a distant signature changes a cell whose own record never moved, and in two hundred trials of one cell holding one value the verdict came out both ways, so nothing stored at the cell explains the difference and what explains it is the bound the cell rests on; the resemblance is structural and never arithmetic, with no continuous amplitudes and no inequality violated by number; structural resemblance, one origin, not a claim about the world. The falsifier: one act that is both local and non-local — a change that travels a distance and also reaches a cell that does not rest on its bound. The two poles would then be one, and this would be a claim about the world rather than a hint.
 
-The cells under the order of rest, with signatures as meets and the phase each origin carries as what they are enriched over, look like an enriched meet-semilattice, and what this library proves would be its representation theory; identity, composition, associativity, commuting and naturality hold for the operations as vectors, while observation is not one of them — it moves the metric and can split a cell no signature could, so it is a functor out of the category and not an arrow inside it, and the join, which does not travel, is a second kind of arrow this conjecture does not name. It is falsified by a pair of the five operations whose composition the axioms do not determine. The join is already known to be absent from them: it does not travel, and naming what it is would be a second kind of arrow this conjecture does not have.
+The cells under the order of rest, with signatures as meets and the phase each origin carries as what they are enriched over, look like an enriched meet-semilattice, and what this library proves would be its representation theory; identity, composition, associativity, commuting and naturality hold for the operations as vectors, while observation is not one of them — it moves the metric and can split a cell no signature could, so it is a functor out of the category and not an arrow inside it, and the join, which does not travel, is a second kind of arrow this conjecture does not name. The falsifier: a pair of the five operations whose composition the axioms do not determine. The join is already known to be absent from them: it does not travel, and naming what it is would be a second kind of arrow this conjecture does not have.
 
-Amplitudes with a phase and no origin, no signed ceiling, no resolution and no epoch band are what is left of a cell when those four fields are dropped, so the measurement problem is the absence of who, imposed symmetries the absence of a signed ceiling, the classical limit the absence of resolution and universal interference the absence of bands; restored, four claims in phase keep exactly the share of the whole their number leaves them against an environment spread over the period, and six origins around one value are six objects read finely and one read coarsely, so how many things there are is a reading; structural resemblance, one origin, not a claim about the world. It is falsified by a result of the usual formalism that cannot be stated with the four fields, or a prediction the restored fields make that the arithmetic forbids. This conjecture is about which structure is missing, not about numbers the arithmetic already gives.
+Amplitudes with a phase and no origin, no signed ceiling, no resolution and no epoch band are what is left of a cell when those four fields are dropped, so the measurement problem is the absence of who, imposed symmetries the absence of a signed ceiling, the classical limit the absence of resolution and universal interference the absence of bands; restored, four claims in phase keep exactly the share of the whole their number leaves them against an environment spread over the period, and six origins around one value are six objects read finely and one read coarsely, so how many things there are is a reading; structural resemblance, one origin, not a claim about the world. The falsifier: a result of the usual formalism that cannot be stated with the four fields, or a prediction the restored fields make that the arithmetic forbids. This conjecture is about which structure is missing, not about numbers the arithmetic already gives.
 
-Four instruments that share no mechanism fold the same way because a measurement is a cell: for a thermometer, a survey, an interferometer and a headcount the five fields are named without strain and the same five operations answer for all four; no number is claimed, only that the table can be filled in every row. It is falsified by an instrument whose reading cannot be written as a floor and a ceiling held by an origin at an epoch and a resolution, without straining any of the five.
+Four instruments that share no mechanism fold the same way because a measurement is a cell: for a thermometer, a survey, an interferometer and a headcount the five fields are named without strain and the same five operations answer for all four; no number is claimed, only that the table can be filled in every row. The falsifier: an instrument whose reading cannot be written as a floor and a ceiling held by an origin at an epoch and a resolution, without straining any of the five.
 
-What carries an encounter is a medium, and a medium is what two origins can both reach: in each instrument the medium can be named and the encounter happens where two origins touch it and nowhere else, so two origins at one cell make information and the same two at two cells make none; structural resemblance, one origin, not a claim about the world. It is falsified by an encounter between two origins with nothing they both reach. Then information would appear where nothing was shared.
+What carries an encounter is a medium, and a medium is what two origins can both reach: in each instrument the medium can be named and the encounter happens where two origins touch it and nowhere else, so two origins at one cell make information and the same two at two cells make none; structural resemblance, one origin, not a claim about the world. The falsifier: an encounter between two origins with nothing they both reach. Then information would appear where nothing was shared.
 
-A field of cells with origins and signatures is a game whose referee is inside it: a move is a claim, a claim alone is potential, two that meet are information, a signature moves every cell that rests on it, and no player may suspend the rule that makes the first four; the claim is that each of five readings of the field matches all five properties; structural resemblance, one origin, not a claim about the world. It is falsified by a reading of the field where a player can suspend the rule that two origins are needed, or where one claim is information. Then the referee would be outside the game.
+A field of cells with origins and signatures is a game whose referee is inside it: a move is a claim, a claim alone is potential, two that meet are information, a signature moves every cell that rests on it, and no player may suspend the rule that makes the first four; the claim is that each of five readings of the field matches all five properties; structural resemblance, one origin, not a claim about the world. The falsifier: a reading of the field where a player can suspend the rule that two origins are needed, or where one claim is information. Then the referee would be outside the game.
 
-The obligatory is maximal: take away any one of its seven parts and what is left is an object already known, and anything added to it is either already inside it or breaks the four states. It is falsified by a part the obligatory lacks that keeps the four states and the six operations and is not a reading of one of them.
+The obligatory is maximal: take away any one of its seven parts and what is left is an object already known, and anything added to it is either already inside it or breaks the four states. The falsifier: a part the obligatory lacks that keeps the four states and the six operations and is not a reading of one of them.
 
 </details>
 
 ## Check
 
-● 178 cases hold
-
-## Pointers
-
-- [Reference](docs/reference.md)
-- Learn from an example: [in phase](docs/learn/in-phase.md), [price](docs/learn/price.md), [signature](docs/learn/signature.md), [thermometer](docs/learn/thermometer.md), [withdrawal](docs/learn/withdrawal.md)
+● 203 cases hold

package/dist/debit/observer.d.ts

@@ -0,0 +1,6 @@
+import type { Interval } from '../lattice/forms.ts';
+import type { Lattice } from '../lattice/lattice.ts';
+import type { World } from '../lattice/obligatory.ts';
+export declare function price<T>(bits: (held: T) => number, before: T, after: T): number;
+export declare function looksLeft(L: Lattice<Interval>, world: World<Interval>, origin: string): number;
+export declare function pay(L: Lattice<Interval>, world: World<Interval>, origin: string): World<Interval>;

package/dist/debit/observer.js

@@ -0,0 +1,15 @@
+import { sign } from "../field/sign.js";
+import { UnitError } from "../lattice/errors.js";
+import { cell, parts } from "../lattice/obligatory.js";
+export function price(bits, before, after) {
+    return bits(before) - bits(after);
+}
+export function looksLeft(L, world, origin) {
+    return parts(L, world.get(origin) ?? cell(origin), world).ceiling.hi;
+}
+export function pay(L, world, origin) {
+    const held = parts(L, world.get(origin) ?? cell(origin), world);
+    if (held.ceiling.hi - 1 < held.floor.lo)
+        throw new UnitError('attention-spent', `obligations: REFUSE·attention ${origin} has no look left: an act nobody pays for is not taken`);
+    return sign(L, world, origin, { lo: L.top.lo, hi: held.ceiling.hi - 1 });
+}

package/dist/field/encounter.d.ts

@@ -1,5 +1,7 @@
 import type { Point, Sighting } from './field.ts';
 import type { Interval } from '../lattice/forms.ts';
+import type { Lattice } from '../lattice/lattice.ts';
+import type { Obligatory, Origin, World } from '../lattice/obligatory.ts';
 export declare function origins(place: Point): number;
 export declare function potential(place: Point): boolean;
 export declare function disagree(place: Point): readonly [Sighting, Sighting] | null;
@@ -7,3 +9,13 @@ export declare function meetAt(place: Point): Interval;
 export declare function latest(places: readonly Point[]): Point | null;
 export declare function verdict(place: Point): string;
 export declare function turned(before: readonly Point[], after: readonly Point[]): readonly Point[];
+export declare function encounter<T>(L: Lattice<T>, c: Obligatory<T>, world?: World<T>): {
+    readonly origins: number;
+    readonly held: T;
+};
+export declare const cancels: (a: Origin, b: Origin) => boolean;
+export declare function pairs(origins: readonly Origin[]): {
+    readonly forks: number;
+    readonly closes: number;
+};
+export declare function laminar(origins: readonly Origin[]): boolean;

package/dist/field/encounter.js

@@ -1,6 +1,8 @@
 import { witnessesIn } from "../debit/debit.js";
 import { key } from "./field.js";
+import { meet } from "./meet.js";
 import { intervals } from "../lattice/forms.js";
+import { live } from "../lattice/obligatory.js";
 const spanning = (spans) => intervals(Math.min(...spans.map((one) => one.lo)), Math.max(...spans.map((one) => one.hi)));
 export function origins(place) {
     return new Set(place.seen.map((s) => s.origin)).size;
@@ -34,3 +36,23 @@ export function turned(before, after) {
     const held = new Map(before.map((p) => [key([{ at: p.at }]), verdict(p)]));
     return after.filter((p) => held.get(key([{ at: p.at }])) !== verdict(p));
 }
+export function encounter(L, c, world = new Map()) {
+    return { origins: new Set(live(c.seen).map((claim) => claim.origin)).size, held: meet(L, c, world) };
+}
+export const cancels = (a, b) => Math.cos(a.phase - b.phase) < 0;
+export function pairs(origins) {
+    let forks = 0;
+    let closes = 0;
+    for (let i = 0; i < origins.length; i += 1)
+        for (let j = i + 1; j < origins.length; j += 1)
+            if (cancels(origins[i], origins[j]))
+                forks += 1;
+            else
+                closes += 1;
+    return { forks, closes };
+}
+export function laminar(origins) {
+    const x = origins.reduce((sum, one) => sum + Math.cos(one.phase), 0);
+    const y = origins.reduce((sum, one) => sum + Math.sin(one.phase), 0);
+    return x * x + y * y > origins.length;
+}

package/dist/field/join.d.ts

@@ -0,0 +1,3 @@
+import type { Lattice } from '../lattice/lattice.ts';
+import type { Obligatory } from '../lattice/obligatory.ts';
+export declare function join<T>(L: Lattice<T>, c: Obligatory<T>, span: T, witness: string, at?: number): Obligatory<T>;

package/dist/field/join.js

@@ -0,0 +1,7 @@
+import { UnitError } from "../lattice/errors.js";
+import { mark } from "../lattice/obligatory.js";
+export function join(L, c, span, witness, at) {
+    if (witness === '')
+        throw new UnitError('join-unwitnessed', 'obligations: REFUSE·join a widening lands only with a witness or the signatures of whoever rests on the old bound');
+    return { ...c, marks: [...(c.marks ?? []), mark({ pole: 'ceiling', reach: 'local', span: L.meet(L.top, span), widens: witness, ...(at === undefined ? {} : { at }) })] };
+}

package/dist/field/meet.d.ts

@@ -0,0 +1,3 @@
+import type { Lattice } from '../lattice/lattice.ts';
+import type { Obligatory, World } from '../lattice/obligatory.ts';
+export declare function meet<T>(L: Lattice<T>, c: Obligatory<T>, world?: World<T>): T;

package/dist/field/meet.js

@@ -0,0 +1,5 @@
+import { parts } from "../lattice/obligatory.js";
+export function meet(L, c, world = new Map()) {
+    const { floor, ceiling } = parts(L, c, world);
+    return L.meet(floor, ceiling);
+}

package/dist/field/observe.d.ts

@@ -0,0 +1,2 @@
+import type { Act, Claim, Obligatory } from '../lattice/obligatory.ts';
+export declare function observe<T>(c: Obligatory<T>, claim: Claim<T>, s?: Act): Obligatory<T>;

package/dist/field/observe.js

@@ -0,0 +1,10 @@
+import { UnitError } from "../lattice/errors.js";
+export function observe(c, claim, s = claim.takes === undefined ? 1 : -1) {
+    const takes = s === 1 ? undefined : claim.takes ?? claim.id;
+    if (s === 1 && claim.takes !== undefined)
+        throw new UnitError('sign-mismatch', 'obligations: REFUSE·observe a claim that takes another back is observed at −1, never at +1');
+    if (s === -1 && takes === undefined)
+        throw new UnitError('withdrawal-unnamed', 'obligations: REFUSE·observe a withdrawal names the claim it takes back, never a value that looks like it');
+    const line = takes === undefined ? claim : { origin: claim.origin, span: claim.span, sign: -1, takes, ...(claim.at === undefined ? {} : { at: claim.at }) };
+    return { ...c, epoch: Math.max(c.epoch, claim.at ?? c.epoch), seen: [...c.seen, line] };
+}

package/dist/field/refine.d.ts

@@ -0,0 +1,2 @@
+import type { Obligatory } from '../lattice/obligatory.ts';
+export declare function refine<T>(c: Obligatory<T>, steps: number): Obligatory<T>;

package/dist/field/refine.js

@@ -0,0 +1,3 @@
+export function refine(c, steps) {
+    return { ...c, at: steps >= c.at.length ? c.at : c.at.slice(0, Math.max(1, steps)) };
+}

package/dist/field/require.d.ts

@@ -0,0 +1,4 @@
+import type { Lattice } from '../lattice/lattice.ts';
+import type { World } from '../lattice/obligatory.ts';
+import type { Line } from './sign.ts';
+export declare function require<T>(L: Lattice<T>, world: World<T>, name: string, span: T, line?: Line): World<T>;

package/dist/field/require.js

@@ -0,0 +1,5 @@
+import { cell, mark } from "../lattice/obligatory.js";
+export function require(L, world, name, span, line = {}) {
+    const held = world.get(name) ?? cell(name);
+    return new Map([...world, [name, { ...held, marks: [...(held.marks ?? []), mark({ pole: 'floor', reach: 'travels', span: L.meet(L.top, span), ...line })] }]]);
+}

package/dist/field/sign.d.ts

@@ -0,0 +1,13 @@
+import type { Lattice } from '../lattice/lattice.ts';
+import type { World } from '../lattice/obligatory.ts';
+export interface Line {
+    readonly id?: string;
+    readonly at?: number;
+    readonly takes?: string;
+}
+export declare function sign<T>(L: Lattice<T>, world: World<T>, name: string, span: T, line?: Line): World<T>;
+export declare function restingOn<T>(world: World<T>): ReadonlyMap<string, readonly string[]>;
+export declare function bites<T>(L: Lattice<T>, world: World<T>, resting: ReadonlyMap<string, readonly string[]>, name: string, span: T): {
+    readonly cells: readonly string[];
+    readonly visits: number;
+};

package/dist/field/sign.js

@@ -0,0 +1,34 @@
+import { cell, live, mark, restOf } from "../lattice/obligatory.js";
+export function sign(L, world, name, span, line = {}) {
+    const held = world.get(name) ?? cell(name);
+    return new Map([...world, [name, { ...held, marks: [...(held.marks ?? []), mark({ pole: 'ceiling', reach: 'travels', span: L.meet(L.top, span), ...line })] }]]);
+}
+export function restingOn(world) {
+    const out = new Map();
+    for (const [name, one] of world)
+        for (const bound of one.restsOn)
+            out.set(bound, [...(out.get(bound) ?? []), name]);
+    return out;
+}
+export function bites(L, world, resting, name, span) {
+    const own = (at) => live(world.get(at)?.marks ?? []).filter((one) => one.pole === 'ceiling' && one.reach === 'travels' && one.widens === undefined)
+        .reduce((held, one) => L.meet(held, one.span), L.top);
+    const above = (at) => restOf(world.get(at) ?? cell(at), world).reduce((held, up) => L.meet(held, own(up)), own(at));
+    const bitten = [];
+    const edge = [[name, above(name)]];
+    const held = new Set([name]);
+    for (let i = 0; i < edge.length; i += 1) {
+        const [here, was] = edge[i];
+        if (L.leq(was, span))
+            continue;
+        bitten.push(here);
+        for (const next of resting.get(here) ?? []) {
+            if (held.has(next))
+                continue;
+            held.add(next);
+            const one = world.get(next);
+            edge.push([next, one !== undefined && one.restsOn.length === 1 ? L.meet(was, own(next)) : above(next)]);
+        }
+    }
+    return { cells: bitten, visits: edge.length };
+}

package/dist/lattice/errors.d.ts

@@ -1,4 +1,4 @@
-export type UnitErrorCode = 'UNKNOWN_LEVEL' | 'MALFORMED' | 'EMPTY_CHAIN' | 'DUPLICATE_LEVEL' | 'NOT_FINITE' | 'UNKNOWN_ROW';
+export type UnitErrorCode = 'UNKNOWN_LEVEL' | 'MALFORMED' | 'EMPTY_CHAIN' | 'DUPLICATE_LEVEL' | 'NOT_FINITE' | 'UNKNOWN_ROW' | 'rest-cycle' | 'widening-travels' | 'withdrawal-unnamed' | 'sign-mismatch' | 'join-unwitnessed' | 'attention-spent';
 export declare class UnitError extends Error {
     readonly code: UnitErrorCode;
     readonly detail: Readonly<Record<string, unknown>>;

package/dist/lattice/obligatory.d.ts

@@ -1,9 +1,27 @@
 import type { Lattice } from './lattice.ts';
+import type { State } from './types.ts';
+export type Act = 1 | -1;
+export interface Origin {
+    readonly name: string;
+    readonly phase: number;
+}
 export interface Claim<T> {
     readonly origin: string;
     readonly span: T;
     readonly id?: string;
     readonly at?: number;
+    readonly sign?: Act;
+    readonly takes?: string;
+    readonly phase?: number;
+}
+export interface Mark<T> {
+    readonly pole: 'floor' | 'ceiling';
+    readonly reach: 'local' | 'travels';
+    readonly span: T;
+    readonly widens?: string;
+    readonly id?: string;
+    readonly at?: number;
+    readonly sign?: Act;
     readonly takes?: string;
 }
 export interface Obligatory<T> {
@@ -11,17 +29,23 @@ export interface Obligatory<T> {
     readonly epoch: number;
     readonly seen: readonly Claim<T>[];
     readonly restsOn: readonly string[];
-    readonly ceiling?: T;
-    readonly witnesses?: readonly string[];
+    readonly marks?: readonly Mark<T>[];
+}
+export type World<T> = ReadonlyMap<string, Obligatory<T>>;
+export interface Cell<T> {
+    readonly floor: T;
+    readonly ceiling: T;
+    readonly origins: readonly Claim<T>[];
+    readonly rest: readonly string[];
+    readonly required: T;
+    readonly signed: T;
 }
 export declare function cell<T>(at: string, epoch?: number, seen?: readonly Claim<T>[], restsOn?: readonly string[]): Obligatory<T>;
-export declare function meet<T>(lattice: Lattice<T>, one: Obligatory<T>, bounds?: ReadonlyMap<string, T>): T;
-export declare function encounter<T>(lattice: Lattice<T>, one: Obligatory<T>, bounds?: ReadonlyMap<string, T>): {
-    readonly origins: number;
-    readonly held: T;
-};
-export declare function observe<T>(one: Obligatory<T>, claim: Claim<T>): Obligatory<T>;
-export declare function sign<T>(lattice: Lattice<T>, bounds: ReadonlyMap<string, T>, name: string, span: T): ReadonlyMap<string, T>;
-export declare function sign<T>(lattice: Lattice<T>, world: readonly Obligatory<T>[], name: string, span: T): readonly Obligatory<T>[];
-export declare function join<T>(lattice: Lattice<T>, one: Obligatory<T>, span: T, witness: string): Obligatory<T>;
-export declare function refine<T>(one: Obligatory<T>, steps: number): Obligatory<T>;
+export declare function mark<T>(one: Mark<T>): Mark<T>;
+export declare function live<L extends {
+    readonly id?: string;
+    readonly takes?: string;
+}>(lines: readonly L[]): readonly L[];
+export declare function restOf<T>(c: Obligatory<T>, world?: World<T>): readonly string[];
+export declare function parts<T>(L: Lattice<T>, c: Obligatory<T>, world?: World<T>): Cell<T>;
+export declare function state<T>(L: Lattice<T>, c: Obligatory<T>, world?: World<T>): State;

package/dist/lattice/obligatory.js

@@ -1,33 +1,58 @@
 import { coordinate } from "../field/field.js";
+import { UnitError } from "./errors.js";
 export function cell(at, epoch = 0, seen = [], restsOn = []) {
     return { at: coordinate(at), epoch, seen, restsOn };
 }
-const standing = (one) => {
-    const taken = new Set(one.seen.flatMap((claim) => (claim.takes === undefined ? [] : [claim.takes])));
-    return one.seen.filter((claim) => claim.takes === undefined && (claim.id === undefined || !taken.has(claim.id)));
-};
-export function meet(lattice, one, bounds = new Map()) {
-    const rested = one.restsOn.flatMap((name) => (bounds.has(name) ? [bounds.get(name)] : []));
-    const own = one.ceiling === undefined ? [] : [one.ceiling];
-    return [...standing(one).map((claim) => claim.span), ...rested, ...own].reduce((held, span) => lattice.meet(held, span), lattice.top);
-}
-export function encounter(lattice, one, bounds) {
-    return { origins: new Set(standing(one).map((claim) => claim.origin)).size, held: meet(lattice, one, bounds) };
+export function mark(one) {
+    if (one.widens !== undefined && one.reach === 'travels') {
+        throw new UnitError('widening-travels', 'obligations: REFUSE·widening-travels a widening stands where it was witnessed and never travels to what rests there', { pole: one.pole });
+    }
+    return one.takes === undefined ? one : { ...one, sign: -1 };
 }
-export function observe(one, claim) {
-    return { ...one, epoch: Math.max(one.epoch, claim.at ?? one.epoch), seen: [...one.seen, claim] };
+export function live(lines) {
+    const taken = new Set(lines.flatMap((line) => (line.takes === undefined ? [] : [line.takes])));
+    return lines.filter((line) => line.takes === undefined && (line.id === undefined || !taken.has(line.id)));
 }
-export function sign(lattice, held, name, span) {
-    if (!(held instanceof Map)) {
-        return held.map((one) => (one.restsOn.includes(name) ? { ...one, ceiling: lattice.meet(one.ceiling ?? lattice.top, span) } : one));
+export function restOf(c, world = new Map()) {
+    const own = c.at.join('/');
+    const out = [];
+    const held = new Set();
+    const edge = [...c.restsOn];
+    for (let i = 0; i < edge.length; i += 1) {
+        const name = edge[i];
+        if (name === own)
+            throw new UnitError('rest-cycle', `obligations: REFUSE·rest ${own} rests on itself: an order of rest with a cycle has no fold to reach`, { at: own });
+        if (held.has(name))
+            continue;
+        held.add(name);
+        out.push(name);
+        edge.push(...(world.get(name)?.restsOn ?? []));
     }
-    return new Map([...held, [name, lattice.meet(held.get(name) ?? lattice.top, span)]]);
+    return out;
 }
-export function join(lattice, one, span, witness) {
-    if (witness === '')
-        throw new Error('REFUSE·join a widening lands only with a witness or the signatures of whoever rests on the old bound');
-    return { ...one, ceiling: lattice.join(one.ceiling ?? lattice.top, span), witnesses: [...(one.witnesses ?? []), witness] };
+export function parts(L, c, world = new Map()) {
+    const rest = restOf(c, world);
+    const above = rest.flatMap((name) => live(world.get(name)?.marks ?? []).filter((one) => one.reach === 'travels' && one.widens === undefined));
+    const marks = [...live(c.marks ?? []), ...above].sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
+    let required = L.top;
+    let signed = L.top;
+    for (const one of marks) {
+        if (one.pole === 'floor')
+            required = L.meet(required, one.span);
+        else
+            signed = one.widens === undefined ? L.meet(signed, one.span) : L.join(signed, one.span);
+    }
+    const origins = live(c.seen);
+    const held = origins.reduce((acc, claim) => L.meet(acc, claim.span), L.top);
+    return { floor: L.meet(required, held), ceiling: L.meet(signed, held), origins, rest, required, signed };
 }
-export function refine(one, steps) {
-    return { ...one, at: steps >= one.at.length ? one.at : one.at.slice(0, Math.max(1, steps)) };
+export function state(L, c, world = new Map()) {
+    const { floor, ceiling, origins, required, signed } = parts(L, c, world);
+    if (!L.inhabited(L.meet(required, signed)))
+        return 'CONFLICT';
+    if (new Set(origins.map((claim) => claim.origin)).size < 2)
+        return 'REQUIRED';
+    if (!L.inhabited(origins.reduce((acc, claim) => L.meet(acc, claim.span), L.top)))
+        return 'CONFLICT';
+    return L.inhabited(L.meet(floor, ceiling)) ? 'FREE' : 'FORBIDDEN';
 }

package/dist/views/field/physics.js

@@ -1,4 +1,4 @@
-import { meet } from "../../lattice/obligatory.js";
+import { meet } from "../../field/meet.js";
 import { coherence } from "./wave.js";
 export function disturbance(lattice, one, claim) {
     const was = meet(lattice, one);

package/dist/views/field/policy.js

@@ -1,4 +1,5 @@
-import { encounter, meet } from "../../lattice/obligatory.js";
+import { encounter } from "../../field/encounter.js";
+import { meet } from "../../field/meet.js";
 import { coherence } from "./wave.js";
 import { neighbours, reach } from "../product/reach.js";
 const at = (cell) => cell.at.join('/');

package/dist/views/field/self.js

@@ -1,4 +1,5 @@
-import { meet, observe } from "../../lattice/obligatory.js";
+import { meet } from "../../field/meet.js";
+import { observe } from "../../field/observe.js";
 export function selfFold(lattice, one, epochs, width, spread, seed) {
     let held = seed;
     const next = () => { held = (held * 1103515245 + 12345) % 2147483648; return held / 2147483648; };

package/dist/views/field.d.ts

@@ -1,11 +1,18 @@
 export { foldIn, witnessesIn } from '../debit/debit.ts';
-export { disagree, latest, meetAt, origins, potential, turned } from '../field/encounter.ts';
+export { cancels, disagree, encounter, laminar, latest, meetAt, origins, pairs, potential, turned } from '../field/encounter.ts';
 export { contracts, coordinate, covers, exclusive, key, passes, point, region, resolution, within } from '../field/field.ts';
+export { join } from '../field/join.ts';
+export { meet } from '../field/meet.ts';
+export { observe } from '../field/observe.ts';
+export { refine } from '../field/refine.ts';
+export { require } from '../field/require.ts';
+export { bites, restingOn, sign } from '../field/sign.ts';
 export { converge, endsBeforeNow, present } from '../field/present.ts';
 export { amplitude, coherence, fringes, interfere, phase, seenAs } from './field/wave.ts';
 export type { Claim } from './field/wave.ts';
-export { cell, encounter, join, meet, observe, refine, sign } from '../lattice/obligatory.ts';
-export type { Obligatory } from '../lattice/obligatory.ts';
+export { cell, mark, parts, restOf, state } from '../lattice/obligatory.ts';
+export type { Act, Cell, Mark, Obligatory, Origin, World } from '../lattice/obligatory.ts';
+export { looksLeft, pay, price } from '../debit/observer.ts';
 export { budget, decohere, disturbance, distinct, evolve, sameObject } from './field/physics.ts';
 export { choose, play } from './field/policy.ts';
 export { selfFold } from './field/self.ts';

package/dist/views/field.js

@@ -1,9 +1,16 @@
 export { foldIn, witnessesIn } from "../debit/debit.js";
-export { disagree, latest, meetAt, origins, potential, turned } from "../field/encounter.js";
+export { cancels, disagree, encounter, laminar, latest, meetAt, origins, pairs, potential, turned } from "../field/encounter.js";
 export { contracts, coordinate, covers, exclusive, key, passes, point, region, resolution, within } from "../field/field.js";
+export { join } from "../field/join.js";
+export { meet } from "../field/meet.js";
+export { observe } from "../field/observe.js";
+export { refine } from "../field/refine.js";
+export { require } from "../field/require.js";
+export { bites, restingOn, sign } from "../field/sign.js";
 export { converge, endsBeforeNow, present } from "../field/present.js";
 export { amplitude, coherence, fringes, interfere, phase, seenAs } from "./field/wave.js";
-export { cell, encounter, join, meet, observe, refine, sign } from "../lattice/obligatory.js";
+export { cell, mark, parts, restOf, state } from "../lattice/obligatory.js";
+export { looksLeft, pay, price } from "../debit/observer.js";
 export { budget, decohere, disturbance, distinct, evolve, sameObject } from "./field/physics.js";
 export { choose, play } from "./field/policy.js";
 export { selfFold } from "./field/self.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lapxo/obligations",
-  "version": "0.2.0",
-  "description": "The algebra of a cell: two poles, origins with phase, six operations.",
+  "version": "0.3.0",
+  "description": "The algebra of a cell: two poles, origins with phase, eight acts.",
   "type": "module",
   "license": "MIT",
   "author": "Lapxo",