@bramas/simulant-engine 0.1.0 → 0.1.1

package/dist/explorer.js

@@ -72,7 +72,7 @@ export class Explorer {
                 this.concreteInitial.set(id, { config: s.config, index });
             }
         });
-        const ssync = system.exp.model.round === 'ssync';
+        const fairScheduler = system.exp.model.round !== 'fsync';
         for (let cursor = 0; cursor < this.states.length; cursor++) {
             if ((cursor & 255) === 255)
                 yield;
@@ -101,16 +101,16 @@ export class Explorer {
                     succ.push(id);
                     act.push(new Set(t.activated));
                 }
-                else if (ssync)
+                else if (fairScheduler)
                     for (const i of t.activated)
                         act[at].add(i);
             }
             s.succ = succ;
-            if (ssync)
+            if (fairScheduler)
                 s.act = act;
             this.edges += succ.length;
         }
-        const lasso = this.goal === 'safety' ? undefined : this.findLasso(ssync);
+        const lasso = this.goal === 'safety' ? undefined : this.findLasso(fairScheduler);
         if (lasso)
             return this.result('failure', `an execution never satisfies "${this.goal}"`, lasso);
         if (this.incomplete)
@@ -135,7 +135,7 @@ export class Explorer {
             return false;
         return this.goal === 'eventually' ? s.verdict !== 'success' : true;
     }
-    findLasso(ssync) {
+    findLasso(fairScheduler) {
         for (const scc of this.sccs()) {
             const members = new Set(scc);
             const inside = (u) => this.states[u].succ.map((v, j) => [v, j]).filter(([v]) => members.has(v));
@@ -148,7 +148,7 @@ export class Explorer {
                 continue;
             // Scheduler fairness: every acting agent is activated on some edge of the component.
             const needed = [];
-            if (ssync) {
+            if (fairScheduler) {
                 const C = this.states[scc[0]].config;
                 const acting = C.agents.flatMap((a, i) => this.system.rt.acts(a) === 'never' ? [] : [i]);
                 let fair = true;

package/dist/system.js

@@ -7,7 +7,7 @@ import { check } from "@bramas/simulant-lang/check";
 import { T } from "@bramas/simulant-lang/types";
 import { Compiler, Runtime, } from "./compile.js";
 import { DynamicRing, Ring } from "./topology.js";
-import { encoder, show } from "./values.js";
+import { encoder, equality, show } from "./values.js";
 export class IRError extends Error {
     errors;
     constructor(errors) {
@@ -387,14 +387,15 @@ export class System {
         }
         return agents === C.agents && world === C.world ? C : { agents, world };
     }
-    /** FSYNC activates every agent that acts; SSYNC lets the adversary choose a nonempty set of them. */
+    /** FSYNC: all eligible agents; SSYNC: any nonempty subset; sequential: any singleton. */
     activate(C, k) {
         const eligible = C.agents.flatMap((a, i) => this.rt.acts(a) === 'never' ? [] : [i]);
         if (this.exp.model.round === 'fsync' || eligible.length === 0)
             return k(eligible);
         const w = this.rt.witness;
         let index = 0;
-        for (let size = 1; size <= eligible.length; size++) {
+        const maxSize = this.exp.model.round === 'sequential' ? 1 : eligible.length;
+        for (let size = 1; size <= maxSize; size++) {
             const pick = (from, current) => {
                 if (current.length === size) {
                     w.push({ site: 'activation', index: index++, label: `activates ${current.map(i => `a${i}`).join(', ')}` });
@@ -560,6 +561,25 @@ export function* parameterValues(exp) {
     }
     yield* go(0, {});
 }
+/** Parameters outside their declared domains, without enumerating the settings product. */
+export function parameterDomainViolations(exp, params) {
+    const checked = check(exp);
+    if (checked.errors.length)
+        throw new IRError(checked.errors);
+    const rt = new Runtime(checked.layout);
+    rt.params = params;
+    const compiler = new Compiler(rt, checked.layout, new Map(exp.params.map(p => [p.name, p.type])));
+    const defs = new Map((exp.model.defs ?? []).map(d => [d.name, d]));
+    rt.topo = makeTopology(exp, runDet(compiler.root(exp.model.topology.size, [], defs), []));
+    return exp.params.filter(p => {
+        // Parameters without a domain are supplied by the user and impose no domain restriction.
+        if (!p.domain)
+            return false;
+        const values = runDet(compiler.root(p.domain, [], defs), []);
+        const equal = equality(p.type);
+        return !values.some(value => equal(value, params[p.name]));
+    }).map(p => p.name);
+}
 const definitionCache = new WeakMap();
 /**
  * A definition of an experiment (`def f (x : T) : R := e` in `.sim`), as a function on values:

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@bramas/simulant-engine",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "license": "CECILL-B",
   "type": "module",
   "dependencies": {
-    "@bramas/simulant-lang": "0.1.0"
+    "@bramas/simulant-lang": "0.1.1"
   },
   "exports": {
     "./*": {

package/src/explorer.ts

@@ -3,7 +3,7 @@
  *
  * A reachable `failure` verdict is a counterexample. Liveness goals are
  * decided on the expanded part of the graph with strongly connected
- * components: under a synchronous round every cycle counts; under SSYNC a
+ * components: under a synchronous round every cycle counts; under a fair scheduler a
  * cycle counts only if it is scheduler-fair, i.e. every agent that acts in
  * it is activated somewhere on it. Flags are never cleared, so which agents
  * act is the same in every state of a component.
@@ -38,7 +38,7 @@ export type State = {
   parent?: number;
   /** Successor ids; undefined while the state is not expanded. */
   succ?: number[];
-  /** Per successor edge, the agents some witness activates (SSYNC only). */
+  /** Per successor edge, the agents some witness activates (fair schedulers only). */
   act?: Set<number>[];
 };
 
@@ -133,7 +133,7 @@ export class Explorer {
         this.concreteInitial.set(id, { config: s.config, index });
       }
     });
-    const ssync = system.exp.model.round === 'ssync';
+    const fairScheduler = system.exp.model.round !== 'fsync';
     for (let cursor = 0; cursor < this.states.length; cursor++) {
       if ((cursor & 255) === 255) yield;
       const s = this.states[cursor];
@@ -152,13 +152,13 @@ export class Explorer {
         if (at === undefined) {
           successorIndex.set(id, succ.length);
           succ.push(id); act.push(new Set(t.activated));
-        } else if (ssync) for (const i of t.activated) act[at].add(i);
+        } else if (fairScheduler) for (const i of t.activated) act[at].add(i);
       }
       s.succ = succ;
-      if (ssync) s.act = act;
+      if (fairScheduler) s.act = act;
       this.edges += succ.length;
     }
-    const lasso = this.goal === 'safety' ? undefined : this.findLasso(ssync);
+    const lasso = this.goal === 'safety' ? undefined : this.findLasso(fairScheduler);
     if (lasso) return this.result('failure', `an execution never satisfies "${this.goal}"`, lasso);
     if (this.incomplete) return this.result('incomplete', this.incomplete);
     return this.result('success', 'every admissible execution satisfies the task');
@@ -183,7 +183,7 @@ export class Explorer {
     return this.goal === 'eventually' ? s.verdict !== 'success' : true;
   }
 
-  private findLasso(ssync: boolean): Counterexample | undefined {
+  private findLasso(fairScheduler: boolean): Counterexample | undefined {
     for (const scc of this.sccs()) {
       const members = new Set(scc);
       const inside = (u: number) => this.states[u].succ!.map((v, j) => [v, j] as const).filter(([v]) => members.has(v));
@@ -194,7 +194,7 @@ export class Explorer {
       if (bad === undefined) continue;
       // Scheduler fairness: every acting agent is activated on some edge of the component.
       const needed: [number, number][] = [];
-      if (ssync) {
+      if (fairScheduler) {
         const C = this.states[scc[0]].config;
         const acting = C.agents.flatMap((a, i) => this.system.rt.acts(a) === 'never' ? [] : [i]);
         let fair = true;

package/src/system.ts

@@ -11,7 +11,7 @@ import {
   Compiler, Runtime, type AgentV, type Choice, type Config, type DecisionV, type Effect, type RootFn, type TraceCall,
 } from './compile';
 import { DynamicRing, Ring, type Move, type TopologyRuntime } from './topology';
-import { encoder, show, type V } from './values';
+import { encoder, equality, show, type V } from './values';
 
 export type { AgentV, Choice, Config, DecisionV, TraceCall };
 
@@ -428,13 +428,14 @@ export class System {
     return agents === C.agents && world === C.world ? C : { agents, world };
   }
 
-  /** FSYNC activates every agent that acts; SSYNC lets the adversary choose a nonempty set of them. */
+  /** FSYNC: all eligible agents; SSYNC: any nonempty subset; sequential: any singleton. */
   private activate(C: Config, k: (active: number[]) => void) {
     const eligible = C.agents.flatMap((a, i) => this.rt.acts(a) === 'never' ? [] : [i]);
     if (this.exp.model.round === 'fsync' || eligible.length === 0) return k(eligible);
     const w = this.rt.witness;
     let index = 0;
-    for (let size = 1; size <= eligible.length; size++) {
+    const maxSize = this.exp.model.round === 'sequential' ? 1 : eligible.length;
+    for (let size = 1; size <= maxSize; size++) {
       const pick = (from: number, current: number[]) => {
         if (current.length === size) {
           w.push({ site: 'activation', index: index++, label: `activates ${current.map(i => `a${i}`).join(', ')}` });
@@ -597,6 +598,24 @@ export function* parameterValues(exp: Experiment): Generator<Record<string, V>>
   yield* go(0, {});
 }
 
+/** Parameters outside their declared domains, without enumerating the settings product. */
+export function parameterDomainViolations(exp: Experiment, params: Record<string, V>): string[] {
+  const checked = check(exp);
+  if (checked.errors.length) throw new IRError(checked.errors);
+  const rt = new Runtime(checked.layout);
+  rt.params = params;
+  const compiler = new Compiler(rt, checked.layout, new Map(exp.params.map(p => [p.name, p.type])));
+  const defs = new Map((exp.model.defs ?? []).map(d => [d.name, d]));
+  rt.topo = makeTopology(exp, runDet(compiler.root(exp.model.topology.size, [], defs), []));
+  return exp.params.filter(p => {
+    // Parameters without a domain are supplied by the user and impose no domain restriction.
+    if (!p.domain) return false;
+    const values = runDet(compiler.root(p.domain, [], defs), []) as V[];
+    const equal = equality(p.type);
+    return !values.some(value => equal(value, params[p.name]));
+  }).map(p => p.name);
+}
+
 const definitionCache = new WeakMap<Experiment, Map<string, (...args: V[]) => V>>();
 
 /**