tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e3e5dd576

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (252) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +18 -4
  7. package/dist/index.d.ts +18 -4
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +56 -56
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -44
  16. package/dist/run.js +42 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +49 -44
  20. package/dist/transfer.js +48 -43
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +14 -2
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +516 -280
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +18 -4
  33. package/src/cli/tlc.ts +18 -12
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +190 -1
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +123 -38
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +370 -99
  42. package/src/exit-codes.ts +28 -14
  43. package/src/instances.ts +135 -11
  44. package/src/java-hash.ts +14 -0
  45. package/src/java-overrides.ts +2 -2
  46. package/src/levels.ts +675 -236
  47. package/src/lexer.ts +12 -2
  48. package/src/liveness-checker.ts +179 -60
  49. package/src/liveness.ts +51 -10
  50. package/src/obligations/index.ts +1 -1
  51. package/src/obligations/normalize.ts +1 -4
  52. package/src/obligations/printer.ts +5 -5
  53. package/src/obligations/source.ts +2 -0
  54. package/src/parallel-worker.ts +8 -2
  55. package/src/parallel.ts +5 -0
  56. package/src/parser.ts +180 -149
  57. package/src/prover/isabelle/isar/attrib.ts +4 -4
  58. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  59. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  60. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  61. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  62. package/src/prover/isabelle/pure/term.ts +3 -3
  63. package/src/prover/prep/md5.ts +26 -29
  64. package/src/prover/smt/rewrite.ts +2 -7
  65. package/src/prover/smt/simplify.ts +1 -1
  66. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  67. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  68. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  69. package/src/prover/smt/solver/ast-lt.ts +1 -1
  70. package/src/prover/smt/solver/ast.ts +66 -14
  71. package/src/prover/smt/solver/auf-solver.ts +23 -12
  72. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  73. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  74. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  75. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  76. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  77. package/src/prover/smt/solver/card2bv.ts +35 -18
  78. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  79. package/src/prover/smt/solver/context.ts +84 -15
  80. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  81. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  82. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  83. package/src/prover/smt/solver/diff-neq.ts +1 -2
  84. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  85. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  86. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  87. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  88. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  89. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  90. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  91. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  92. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  93. package/src/prover/smt/solver/euf/mam.ts +1 -5
  94. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  95. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  96. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  97. package/src/prover/smt/solver/factor.ts +36 -14
  98. package/src/prover/smt/solver/fd-solver.ts +608 -139
  99. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  100. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  101. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  102. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  103. package/src/prover/smt/solver/goal.ts +6 -3
  104. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  105. package/src/prover/smt/solver/hashtable.ts +4 -0
  106. package/src/prover/smt/solver/internalizer.ts +1 -1
  107. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  108. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  109. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  110. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  111. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  112. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  113. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  114. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  115. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  116. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  117. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  118. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  119. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  120. package/src/prover/smt/solver/maxcore.ts +2 -1
  121. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  122. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  123. package/src/prover/smt/solver/model-checker.ts +1 -1
  124. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  125. package/src/prover/smt/solver/model-generator.ts +85 -43
  126. package/src/prover/smt/solver/mpf.ts +2 -4
  127. package/src/prover/smt/solver/mus.ts +2 -3
  128. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  129. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  130. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  131. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  132. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  133. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  134. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  135. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  136. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  137. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  138. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  139. package/src/prover/smt/solver/nlqsat.ts +1 -1
  140. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  141. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  142. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  143. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  144. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  145. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  146. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  147. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  148. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  149. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  150. package/src/prover/smt/solver/nnf.ts +6 -2
  151. package/src/prover/smt/solver/opt-context.ts +21 -7
  152. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  153. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  154. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  155. package/src/prover/smt/solver/opt-solver.ts +10 -6
  156. package/src/prover/smt/solver/optsmt.ts +1 -1
  157. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  158. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  159. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  160. package/src/prover/smt/solver/probes.ts +88 -23
  161. package/src/prover/smt/solver/proto-model.ts +8 -8
  162. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  163. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  164. package/src/prover/smt/solver/qe-lite.ts +2 -2
  165. package/src/prover/smt/solver/qe.ts +3 -2
  166. package/src/prover/smt/solver/qsat.ts +23 -8
  167. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  168. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  169. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  170. package/src/prover/smt/solver/rewriter.ts +31 -25
  171. package/src/prover/smt/solver/rlimit.ts +7 -3
  172. package/src/prover/smt/solver/sat/config.ts +1 -1
  173. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  174. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  175. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  176. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  177. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  178. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  179. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  180. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  181. package/src/prover/smt/solver/sat/solver.ts +27 -47
  182. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  183. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  184. package/src/prover/smt/solver/seq-derive.ts +2 -2
  185. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  186. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  187. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  188. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  189. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  190. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  191. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  192. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  193. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  194. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  195. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  196. package/src/prover/smt/solver/smt-setup.ts +106 -13
  197. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  198. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  199. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  200. package/src/prover/smt/solver/solver.ts +18 -3
  201. package/src/prover/smt/solver/tactic.ts +350 -195
  202. package/src/prover/smt/solver/theory-bv.ts +13 -3
  203. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  204. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  205. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  206. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  207. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  208. package/src/prover/smt/solver/theory-lra.ts +1 -1
  209. package/src/prover/smt/solver/theory-pb.ts +24 -7
  210. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  211. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  212. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  213. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  214. package/src/prover/tlapm/cache.ts +8 -8
  215. package/src/prover/zenon/index-table.ts +5 -2
  216. package/src/prover/zenon/isar-case.ts +1 -1
  217. package/src/prover/zenon/isar.ts +2 -2
  218. package/src/prover/zenon/phrase.ts +1 -1
  219. package/src/resolve.ts +1274 -257
  220. package/src/runtime.ts +7 -1
  221. package/src/sany/builtins.ts +10 -10
  222. package/src/sany/generation.ts +5 -15
  223. package/src/sany/generator-def-entries.ts +123 -36
  224. package/src/sany/generator-definitions.ts +5 -3
  225. package/src/sany/generator-expressions.ts +60 -37
  226. package/src/sany/generator-proofs.ts +18 -12
  227. package/src/sany/generator.ts +12 -6
  228. package/src/sany/lexer.ts +15 -7
  229. package/src/sany/modules.ts +4 -2
  230. package/src/sany/nodes.ts +1 -1
  231. package/src/sany/selectors.ts +11 -6
  232. package/src/sany/xml.ts +2 -3
  233. package/src/search.ts +319 -135
  234. package/src/simulate.ts +235 -182
  235. package/src/spec-description.ts +8 -6
  236. package/src/standard-definitions.ts +1 -0
  237. package/src/standard-modules.ts +56 -22
  238. package/src/subexpressions.ts +564 -138
  239. package/src/successors.ts +37 -13
  240. package/src/symmetry.ts +2 -1
  241. package/src/tlc/jar-data.ts +10 -0
  242. package/src/tlc/messages.ts +3 -3
  243. package/src/tlc/order.ts +14 -3
  244. package/src/tlc/random.ts +2 -1
  245. package/src/tlc/replay.ts +67 -43
  246. package/src/tlc/tlc-operators.ts +10 -8
  247. package/src/tlc/tlcext-operators.ts +44 -15
  248. package/src/tlc/trace-spec.ts +9 -22
  249. package/src/trace-liveness.ts +529 -0
  250. package/src/typed-tier.ts +52 -31
  251. package/src/typescript/types.ts +2 -2
  252. package/src/values.ts +150 -79
package/src/search.ts CHANGED
@@ -17,7 +17,11 @@ import type {
17
17
  import { parseConfig, type ConfigValue, type ModelConfig } from "./config";
18
18
  import {
19
19
  addCoverageRelation,
20
+ buildCoverage,
21
+ createCoverage,
22
+ createCoverageEnvironment,
20
23
  getCoverageLabel,
24
+ getCoverageReport,
21
25
  runAtCoverageNode,
22
26
  type Coverage,
23
27
  type CoverageKind,
@@ -28,9 +32,12 @@ import {
28
32
  isExpressionImpure,
29
33
  isImpureDefinition,
30
34
  } from "./dependencies";
31
- import { createEnvironment, type ResolvedModuleOperator } from "./environment";
32
35
  import {
33
- isStackOverflow,
36
+ createEnvironment,
37
+ type ResolvedModuleOperator,
38
+ type RuntimeInvariant,
39
+ } from "./environment";
40
+ import {
34
41
  TlaConfigError,
35
42
  TlaEvaluationError,
36
43
  TlaModuleError,
@@ -49,6 +56,7 @@ import {
49
56
  type Context,
50
57
  type Environment,
51
58
  type Scope,
59
+ type State,
52
60
  } from "./evaluate";
53
61
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
54
62
  import type { JavaOverride } from "./java-overrides";
@@ -63,10 +71,12 @@ import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty
63
71
  import { getLiveExpressions } from "./liveness-checker";
64
72
  import { prettyPrint } from "./pretty-print";
65
73
  import { getPossibleCounts, type CheckerRuntime } from "./runtime";
74
+ import { createIncompleteSuccessorError } from "./successors";
66
75
  import {
67
76
  getSpecDescription,
68
77
  getSpecificationValue,
69
78
  getSubscriptVariables,
79
+ type SpecAction,
70
80
  type SpecDescription,
71
81
  } from "./spec-description";
72
82
  import { getRepresentative, getSymmetryGroup, type Images } from "./symmetry";
@@ -79,14 +89,17 @@ import {
79
89
  withHeadline,
80
90
  } from "./tlc/messages";
81
91
  import { createTlcOrder } from "./tlc/order";
92
+ import { getPrimedRanges, walkSuccessors } from "./tlc/replay";
82
93
  import { getTlcFingerprint, getTlcFingerprints, setFingerprintPolynomial } from "./tlc/fingerprint";
83
94
  import type { TlcVersion } from "./tlc/version";
84
95
  import {
96
+ createModelValue,
85
97
  formatValue,
86
98
  freezeStringOrder,
87
99
  getWrittenPairs,
88
100
  isFunctionValue,
89
101
  isUpdatedElementOf,
102
+ markNormalized,
90
103
  setAliasName,
91
104
  setStringOrder,
92
105
  setValueOptions,
@@ -95,8 +108,9 @@ import {
95
108
  type Value,
96
109
  } from "./values";
97
110
 
98
- export interface StandardInput {
111
+ export interface CliSettings {
99
112
  readLine?: () => string | undefined;
113
+ runtimeInvariants?: RuntimeInvariant[];
100
114
  }
101
115
 
102
116
  interface EnvironmentSettings
@@ -121,7 +135,7 @@ interface EnvironmentSettings
121
135
  | "isLazyValueExpanded"
122
136
  | "isViewPrinted"
123
137
  >,
124
- StandardInput {}
138
+ CliSettings {}
125
139
 
126
140
  interface NamedExpression {
127
141
  name: string;
@@ -207,14 +221,7 @@ const isLiteralDefinition = (definition: Definition) =>
207
221
 
208
222
  const getConstantValue = (name: string, definition: Definition, environment: Environment) => {
209
223
  if (environment.constants.has(name)) return environment.constants.get(name);
210
- if (!isConstantLevel(definition, environment) || isLiteralDefinition(definition))
211
- return undefined;
212
- try {
213
- return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
214
- } catch (error) {
215
- if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
216
- throw error;
217
- }
224
+ return isLiteralDefinition(definition) ? undefined : getStartupValue(definition, environment);
218
225
  };
219
226
 
220
227
  const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
@@ -381,12 +388,20 @@ const getSpecification = (
381
388
  let isUntaggedFound = false;
382
389
  expandTemporal(definition.body, undefined, environment, false).forEach((item) => {
383
390
  const conjunct = item.expression;
384
- if (isConstantTrue(item, environment, "spec")) return;
391
+ // TLC takes a state-level definition of the spec whole as an initial predicate.
392
+ const isInitial = item.path.some((name) => {
393
+ const expanded = getDefinition(name, environment);
394
+ return (
395
+ expanded?.kind === "Operator" &&
396
+ getLevel(expanded.body, undefined, environment) === VARIABLE_LEVEL
397
+ );
398
+ });
399
+ if (!isInitial && isConstantTrue(item, environment, "spec")) return;
385
400
  const variableIndex =
386
401
  conjunct.kind === "Identifier" && !isLocallyResolved(conjunct)
387
402
  ? environment.variableIndex.get(conjunct.name)
388
403
  : undefined;
389
- if (conjunct.kind === "Identifier" && variableIndex !== undefined) {
404
+ if (!isInitial && conjunct.kind === "Identifier" && variableIndex !== undefined) {
390
405
  const range = variableLocations[variableIndex].range;
391
406
  throw new TlaConfigError(
392
407
  `The operator ${conjunct.name}, which equals ${range ? formatRange(range) : conjunct.name},\ncannot be used as a spec`,
@@ -651,22 +666,28 @@ const getPredicate = (expression: Expression, environment: Environment) => {
651
666
  };
652
667
 
653
668
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
654
- named.flatMap((item) =>
655
- getConjuncts(item.expression, environment).map((expression) => {
656
- const variables =
657
- item.scope === undefined ? getReadVariables(expression, environment) : undefined;
658
- return {
659
- name: item.name,
660
- expression,
661
- scope: item.scope,
662
- variables,
663
- membership: getMembership(expression, variables, environment),
664
- predicate: getPredicate(item.expression, environment),
665
- };
666
- }),
667
- );
669
+ named.flatMap((item) => {
670
+ const predicate = getPredicate(item.expression, environment);
671
+ const isImpure =
672
+ item.scope === undefined && getReadVariables(predicate, environment) === undefined;
673
+ // TLC evaluates an invariant whole, so one that prints isn't split into conjuncts.
674
+ return (isImpure ? [predicate] : getConjuncts(item.expression, environment)).map(
675
+ (expression) => {
676
+ const variables =
677
+ item.scope === undefined ? getReadVariables(expression, environment) : undefined;
678
+ return {
679
+ name: item.name,
680
+ expression,
681
+ scope: item.scope,
682
+ variables,
683
+ membership: getMembership(expression, variables, environment),
684
+ predicate,
685
+ };
686
+ },
687
+ );
688
+ });
668
689
 
669
- const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
690
+ const isUnchangedFor = (stateCheck: StateCheck, state: State, parent: Value[] | undefined) => {
670
691
  const variables = stateCheck.variables;
671
692
  if (!parent || !variables) return false;
672
693
  for (let index = 0; index < variables.length; index++) {
@@ -684,31 +705,42 @@ const isWideConfigValue = (value: ConfigValue): boolean =>
684
705
  ? WIDE_CHARACTER.test(value.value)
685
706
  : value.kind === "Set" && value.elements.some(isWideConfigValue);
686
707
 
687
- const isWideExpression = (expression: Expression): boolean =>
688
- (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
689
- (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
690
- getChildren(expression).some(isWideExpression);
708
+ const isWideExpression = (expression: Expression, checked: Set<Expression>): boolean => {
709
+ if (expression.kind === "Selection") {
710
+ if (checked.has(expression.expression)) return false;
711
+ checked.add(expression.expression);
712
+ }
713
+ return (
714
+ (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
715
+ (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
716
+ getChildren(expression).some((child) => isWideExpression(child, checked))
717
+ );
718
+ };
691
719
 
692
720
  // TLC fingerprints a string by the low byte of each character, so it merges states whose strings differ only above U+00FF.
693
- const hasWideString = (config: ModelConfig, environment: Environment) =>
694
- config.constants.some(
695
- (constant) =>
696
- isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
697
- ) ||
698
- [...environment.definitions.values()].some(
699
- (definition) =>
700
- isWideExpression(definition.body) ||
701
- (definition.kind === "Function" &&
702
- definition.bounds.some((bound) => isWideExpression(bound.set))),
721
+ const hasWideString = (config: ModelConfig, environment: Environment) => {
722
+ const checked = new Set<Expression>();
723
+ return (
724
+ config.constants.some(
725
+ (constant) =>
726
+ isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
727
+ ) ||
728
+ [...environment.definitions.values()].some(
729
+ (definition) =>
730
+ isWideExpression(definition.body, checked) ||
731
+ (definition.kind === "Function" &&
732
+ definition.bounds.some((bound) => isWideExpression(bound.set, checked))),
733
+ )
703
734
  );
735
+ };
704
736
 
705
737
  export interface Search {
706
738
  properties: Properties;
707
739
  toRecord: (state: Value[]) => Record<string, Value>;
708
740
  evaluateAlias: (
709
741
  alias: string,
710
- state: Value[],
711
- next: Value[] | undefined,
742
+ state: State,
743
+ next: State | undefined,
712
744
  isTool: boolean,
713
745
  ) => Record<string, Value>;
714
746
  spec: Specification;
@@ -733,22 +765,23 @@ export interface Search {
733
765
  }
734
766
  | undefined;
735
767
  findViolatedInvariant: (state: Value[], parent?: Value[]) => StateCheck | undefined;
736
- getViolatedInvariants: (state: Value[]) => StateCheck[];
768
+ forEachViolatedInvariant: (state: Value[], onViolated: (invariant: StateCheck) => void) => void;
737
769
  checkReplayedInitialState: (
738
770
  state: Value[],
739
771
  tracing: Environment,
740
772
  addFingerprint: () => void,
741
- ) => Pick<InitialStateViolation, "status" | "name"> | undefined;
773
+ onViolated: (violation: Pick<InitialStateViolation, "status" | "name">) => void,
774
+ ) => void;
742
775
  checkReplayedSuccessor: (
743
776
  state: Value[],
744
777
  next: Value[],
745
778
  tracing: Environment,
746
779
  addFingerprint: () => boolean,
747
780
  ) => boolean;
748
- satisfiesConstraints: (state: Value[], parent?: Value[]) => boolean;
781
+ satisfiesConstraints: (state: State, parent?: Value[]) => boolean;
749
782
  findFailedInitialPredicate: (state: Value[]) => NamedExpression | undefined;
750
783
  findViolatedActionProperty: (state: Value[], next: Value[]) => ActionProperty | undefined;
751
- satisfiesActionConstraints: (state: Value[], next: Value[]) => boolean;
784
+ satisfiesActionConstraints: (state: Value[], next: State) => boolean;
752
785
  getExcludingConstraints: (state: Value[], next: Value[]) => string[];
753
786
  trackStatePossible: (state: Value[]) => void;
754
787
  trackActionPossible: (state: Value[], next: Value[]) => void;
@@ -778,8 +811,8 @@ export const getIncompleteSuccessorMessage = (
778
811
 
779
812
  export const getContext = (
780
813
  environment: Environment,
781
- state: Value[] | undefined,
782
- next: Value[] | undefined,
814
+ state: State | undefined,
815
+ next: State | undefined,
783
816
  scope?: Scope,
784
817
  ) => ({ environment, scope, state, next });
785
818
 
@@ -812,7 +845,7 @@ const getExpectedBoolean = (expression: Expression, environment: Environment) =>
812
845
 
813
846
  const holdsAsConjunct = (check: StateCheck, context: Context) =>
814
847
  holdsLikeTlc(check.expression, context, (expression, environment) => {
815
- holdsLikeTlc(check.predicate, context);
848
+ if (check.predicate !== check.expression) holdsLikeTlc(check.predicate, context);
816
849
  return getExpectedBoolean(expression, environment);
817
850
  });
818
851
 
@@ -860,7 +893,12 @@ export const createCheckEnvironment = (
860
893
  isStringOrderFrozen = false,
861
894
  ) => {
862
895
  const order = createTlcOrder(options.source, options.loadModule);
863
- setStringOrder(order.getStringOrder(config));
896
+ setStringOrder(
897
+ order.getStringOrder(
898
+ config,
899
+ (options.runtimeInvariants ?? []).flatMap((invariant) => invariant.module ?? []),
900
+ ),
901
+ );
864
902
  setValueOptions(options);
865
903
  setFingerprintPolynomial(options.fingerprintPolynomial ?? 0);
866
904
  if (isStringOrderFrozen) freezeStringOrder();
@@ -883,6 +921,7 @@ export const createCheckEnvironment = (
883
921
  version: options.version,
884
922
  moduleOperators: options.moduleOperators,
885
923
  readLine: options.readLine,
924
+ runtimeInvariants: options.runtimeInvariants,
886
925
  });
887
926
  return { order, specification };
888
927
  };
@@ -895,7 +934,13 @@ export const prepareSearch = (options: CheckOptions) => {
895
934
  const created = createCheckEnvironment(config, options, options.onPrint ?? console.log);
896
935
  const specification = created.specification;
897
936
  reportStartup(specification, config, options.onProgress);
898
- const environment = specification.environment;
937
+ const coverage =
938
+ options.coverage === undefined
939
+ ? undefined
940
+ : createCoverage(specification.environment.variables.length);
941
+ const environment = coverage
942
+ ? createCoverageEnvironment(specification.environment, coverage)
943
+ : specification.environment;
899
944
  let description: SpecDescription | undefined;
900
945
  const getDescription = () =>
901
946
  (description ??= getSpecDescription(config, environment, specification.instanceActions));
@@ -908,10 +953,73 @@ export const prepareSearch = (options: CheckOptions) => {
908
953
  () => created.order.getDeclarationOrder("variable"),
909
954
  options.onProgress,
910
955
  specification.moduleOperators,
956
+ specification.runtimeInvariants,
911
957
  );
912
- return { config, specification, environment, search, getDescription };
958
+ const getCoverage = () =>
959
+ coverage &&
960
+ getCoverageReport(
961
+ coverage,
962
+ environment,
963
+ specification.variableLocations,
964
+ search?.getTlcOrder() ?? [],
965
+ );
966
+ return { config, specification, environment, search, getDescription, coverage, getCoverage };
913
967
  };
914
968
 
969
+ export interface CoveredAction extends SpecAction {
970
+ node: number;
971
+ }
972
+
973
+ export const STOP_WALK = new Error("The walk stopped");
974
+
975
+ export const addActionCoverage = (
976
+ coverage: Coverage,
977
+ environment: Environment,
978
+ description: SpecDescription,
979
+ ) => {
980
+ const addRelations = (kind: "init" | "next", actions: SpecAction[]) =>
981
+ actions.map((action): CoveredAction => ({
982
+ ...action,
983
+ node: addCoverageRelation(
984
+ coverage,
985
+ kind,
986
+ getCoverageLabel(action.name, action.expression, environment),
987
+ action.expression,
988
+ action.scope,
989
+ ),
990
+ }));
991
+ const inits = addRelations("init", description.inits);
992
+ const actions = addRelations("next", description.actions);
993
+ buildCoverage(coverage, environment, getPrimedRanges(actions, environment));
994
+ return { inits, actions };
995
+ };
996
+
997
+ export const walkCoveredSuccessors = (
998
+ coverage: Coverage,
999
+ action: CoveredAction,
1000
+ state: Value[],
1001
+ environment: Environment,
1002
+ onState: (successor: Value[]) => void,
1003
+ onIncomplete = (partial: State, name: string | undefined): void => {
1004
+ throw createIncompleteSuccessorError(partial, name, environment);
1005
+ },
1006
+ ) =>
1007
+ walkSuccessors(
1008
+ action,
1009
+ action.node,
1010
+ state,
1011
+ environment,
1012
+ (successor) => {
1013
+ coverage.primary[action.node]++;
1014
+ onState(successor);
1015
+ },
1016
+ (partial) => {
1017
+ coverage.primary[action.node]++;
1018
+ onIncomplete(partial, action.name);
1019
+ return true;
1020
+ },
1021
+ );
1022
+
915
1023
  export const reportAssumptionViolation = (
916
1024
  assumptions: Assumption[],
917
1025
  environment: Environment,
@@ -948,6 +1056,7 @@ export const createSearch = (
948
1056
  getVariableOrder: () => string[],
949
1057
  onProgress?: CheckOptions["onProgress"],
950
1058
  moduleOperators: ResolvedModuleOperator[] = [],
1059
+ runtimeInvariants: RuntimeInvariant[] = [],
951
1060
  ): Search | undefined => {
952
1061
  const getModuleOperators = (kind: ResolvedModuleOperator["kind"]) =>
953
1062
  moduleOperators
@@ -976,12 +1085,12 @@ export const createSearch = (
976
1085
  text: `Implied-temporal checking is a tautology.\nThe temporal formula ${live} at ${formatRange(liveRange)} equals\nthe fairness constraints of the behavior specification ${specName} at ${formatRange(specRange)}.\nTherefore, checking whether ${specName} => ${live} using TLC will never result in a violation of ${live}.`,
977
1086
  });
978
1087
  }
979
- const invariants = getStateChecks([...configInvariants, ...properties.invariants], environment);
980
- const invariantPredicates = [
981
- ...new Map(invariants.map((invariant) => [invariant.predicate, invariant])).values(),
982
- ];
1088
+ const checkedInvariants = getStateChecks(
1089
+ [...configInvariants, ...properties.invariants],
1090
+ environment,
1091
+ );
983
1092
  const isCheckingBehaviors =
984
- invariants.length > 0 ||
1093
+ checkedInvariants.length > 0 ||
985
1094
  properties.actionProperties.length > 0 ||
986
1095
  properties.liveness.length > 0;
987
1096
  if (
@@ -999,6 +1108,22 @@ export const createSearch = (
999
1108
  if (spec.next === undefined && isCheckingBehaviors) {
1000
1109
  throw new TlaConfigError("The configuration file did not specify the next state predicate.");
1001
1110
  }
1111
+ const runtimeChecks = getStateChecks(
1112
+ runtimeInvariants.map((invariant) => {
1113
+ const definition = getDefinition(invariant.name, environment);
1114
+ return {
1115
+ name: invariant.name,
1116
+ expression:
1117
+ definition?.kind === "Operator" ? definition.body : createIdentifier(invariant.name),
1118
+ scope: undefined,
1119
+ };
1120
+ }),
1121
+ environment,
1122
+ );
1123
+ const invariants = [...checkedInvariants, ...runtimeChecks];
1124
+ const invariantPredicates = [
1125
+ ...new Map(invariants.map((invariant) => [invariant.predicate, invariant])).values(),
1126
+ ];
1002
1127
  const namedConstraints = getNamedExpressions(
1003
1128
  "constraint",
1004
1129
  [...config.constraints, ...getModuleOperators("constraint").map((operator) => operator.name)],
@@ -1023,8 +1148,20 @@ export const createSearch = (
1023
1148
  ...getCoveredChecks("invariant", configInvariants),
1024
1149
  ...getCoveredChecks("invariant", properties.invariants, false),
1025
1150
  ];
1151
+ const coveredInvariantChecks = new Map(
1152
+ [...configInvariants, ...properties.invariants].map((item, index) => [
1153
+ getPredicate(item.expression, environment),
1154
+ coveredInvariants[index],
1155
+ ]),
1156
+ );
1026
1157
  const coveredActionConstraints = getCoveredChecks("constraint", actionConstraints);
1027
1158
  const coveredConstraints = getCoveredChecks("constraint", namedConstraints);
1159
+ const coveredConstraintChecks = new Map(
1160
+ coveredConstraints.map((check) => [check.expression, check]),
1161
+ );
1162
+ const constraintPredicates = [
1163
+ ...new Map(constraints.map((constraint) => [constraint.predicate, constraint])).values(),
1164
+ ];
1028
1165
  const coveredInitialPredicates = getCoveredChecks("implied", properties.initialPredicates, false);
1029
1166
  const coveredActionProperties = getCoveredChecks(
1030
1167
  "implied",
@@ -1034,8 +1171,8 @@ export const createSearch = (
1034
1171
  const evaluateCovered = (
1035
1172
  covered: Coverage,
1036
1173
  check: CoveredCheck,
1037
- state: Value[],
1038
- next: Value[] | undefined,
1174
+ state: State,
1175
+ next: State | undefined,
1039
1176
  ) => {
1040
1177
  try {
1041
1178
  return runAtCoverageNode(covered, check.node, () =>
@@ -1045,10 +1182,15 @@ export const createSearch = (
1045
1182
  return undefined;
1046
1183
  }
1047
1184
  };
1048
- const isCoveredHeld = (checks: CoveredCheck[], state: Value[], next?: Value[]) =>
1049
- coverage !== undefined &&
1050
- checks.every((check) => evaluateCovered(coverage, check, state, next) === true);
1051
- const satisfiesCovered = (checks: CoveredCheck[], state: Value[], next?: Value[]) => {
1185
+ const holdsReplayed = (
1186
+ covered: CoveredCheck | undefined,
1187
+ expression: Expression,
1188
+ context: Context,
1189
+ ) =>
1190
+ coverage && covered
1191
+ ? runAtCoverageNode(coverage, covered.node, () => holdsLikeTlc(covered.expression, context))
1192
+ : holdsLikeTlc(expression, context);
1193
+ const satisfiesCovered = (checks: CoveredCheck[], state: State, next?: State) => {
1052
1194
  if (!coverage) return undefined;
1053
1195
  for (const check of checks) {
1054
1196
  const value = evaluateCovered(coverage, check, state, next);
@@ -1103,9 +1245,15 @@ export const createSearch = (
1103
1245
  };
1104
1246
  const getViewValue = (expression: Expression, state: Value[]) =>
1105
1247
  evaluate(expression, getContext(environment, state, undefined));
1248
+ const getRepresentativeState = (state: Value[]) => {
1249
+ // TLC's TLCStateMut#fingerPrint deep-normalizes a state before it evaluates the view.
1250
+ if (view !== undefined) state.forEach(markNormalized);
1251
+ return symmetryGroup === undefined
1252
+ ? state
1253
+ : getRepresentative(state, symmetryGroup, getTlcOrder());
1254
+ };
1106
1255
  const getTlcStateFingerprint = (state: Value[]) => {
1107
- const representative =
1108
- symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, getTlcOrder());
1256
+ const representative = getRepresentativeState(state);
1109
1257
  return getTlcFingerprint(
1110
1258
  view === undefined
1111
1259
  ? getTlcOrder().map((index) => representative[index])
@@ -1113,15 +1261,16 @@ export const createSearch = (
1113
1261
  );
1114
1262
  };
1115
1263
  const findFailedInitialPredicate = (state: Value[]) =>
1116
- isCoveredHeld(coveredInitialPredicates, state)
1117
- ? undefined
1118
- : properties.initialPredicates.find(
1119
- (predicate) =>
1120
- !holdsLikeTlc(
1121
- predicate.expression,
1122
- getContext(environment, state, undefined, predicate.scope),
1123
- ),
1124
- );
1264
+ properties.initialPredicates.find((predicate, index) => {
1265
+ const value =
1266
+ coverage && evaluateCovered(coverage, coveredInitialPredicates[index], state, undefined);
1267
+ return typeof value === "boolean"
1268
+ ? !value
1269
+ : !holdsLikeTlc(
1270
+ predicate.expression,
1271
+ getContext(environment, state, undefined, predicate.scope),
1272
+ );
1273
+ });
1125
1274
  const violatingStates = new WeakSet<Value[]>();
1126
1275
  const isViolated = (invariant: StateCheck, state: Value[], parent: Value[] | undefined) => {
1127
1276
  const checkedParent = parent && !violatingStates.has(parent) ? parent : undefined;
@@ -1145,6 +1294,21 @@ export const createSearch = (
1145
1294
  );
1146
1295
  }
1147
1296
  };
1297
+ const isPredicateViolated = (
1298
+ predicate: StateCheck,
1299
+ state: Value[],
1300
+ parent: Value[] | undefined,
1301
+ ) => {
1302
+ const covered = coveredInvariantChecks.get(predicate.predicate);
1303
+ const value =
1304
+ coverage && covered ? evaluateCovered(coverage, covered, state, undefined) : undefined;
1305
+ return typeof value === "boolean"
1306
+ ? !value
1307
+ : invariants.some(
1308
+ (invariant) =>
1309
+ invariant.predicate === predicate.predicate && isViolated(invariant, state, parent),
1310
+ );
1311
+ };
1148
1312
  const isFingerprintedLikeTlc = hasWideString(config, environment);
1149
1313
  runtime.getFingerprint = getTlcStateFingerprint;
1150
1314
  const findUnwitnessedPossible = () => {
@@ -1180,7 +1344,7 @@ export const createSearch = (
1180
1344
  )
1181
1345
  .join("")
1182
1346
  : prettyPrint(formatValue(getViewValue(expression, state)));
1183
- const holdsActionConstraint = (constraint: NamedExpression, state: Value[], next: Value[]) =>
1347
+ const holdsActionConstraint = (constraint: NamedExpression, state: Value[], next: State) =>
1184
1348
  holdsLikeTlc(
1185
1349
  constraint.expression,
1186
1350
  getContext(environment, state, next),
@@ -1200,14 +1364,16 @@ export const createSearch = (
1200
1364
  spec,
1201
1365
  toRecord,
1202
1366
  evaluateAlias: (alias, state, next, isTool) => {
1367
+ const getStateRecord = () =>
1368
+ toRecord(state.map((value) => value ?? createModelValue("null")));
1203
1369
  try {
1204
1370
  getConfigDefinition("alias", alias, environment);
1205
1371
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
1206
1372
  const record = toAliasRecord(value);
1207
- return record === undefined ? toRecord(state) : setAliasName(record, alias);
1373
+ return record === undefined ? getStateRecord() : setAliasName(record, alias);
1208
1374
  } catch (error) {
1209
1375
  if (!(error instanceof TlaConfigError || error instanceof TlaEvaluationError)) throw error;
1210
- return { ...toRecord(state), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1376
+ return { ...getStateRecord(), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1211
1377
  }
1212
1378
  },
1213
1379
  isSymmetric: symmetryGroup !== undefined,
@@ -1291,64 +1457,81 @@ export const createSearch = (
1291
1457
  },
1292
1458
  getFingerprintState: (state) => {
1293
1459
  if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
1294
- const representative =
1295
- symmetryGroup === undefined
1296
- ? state
1297
- : getRepresentative(state, symmetryGroup, getTlcOrder());
1460
+ const representative = getRepresentativeState(state);
1298
1461
  return view === undefined ? representative : [getViewValue(view.expression, representative)];
1299
1462
  },
1300
1463
  findViolatedInvariant: (state, parent) => {
1301
- if (isCoveredHeld(coveredInvariants, state)) return undefined;
1302
- const violated = invariants.find((invariant) => isViolated(invariant, state, parent));
1464
+ const violated =
1465
+ coverage === undefined
1466
+ ? invariants.find((invariant) => isViolated(invariant, state, parent))
1467
+ : invariantPredicates.find((predicate) => isPredicateViolated(predicate, state, parent));
1303
1468
  if (violated) violatingStates.add(state);
1304
1469
  return violated;
1305
1470
  },
1306
- getViolatedInvariants: (state) => {
1307
- const violated = invariantPredicates.filter((predicate) =>
1308
- invariants.some(
1309
- (invariant) =>
1310
- invariant.predicate === predicate.predicate && isViolated(invariant, state, undefined),
1471
+ forEachViolatedInvariant: (state, onViolated) => {
1472
+ for (const predicate of invariantPredicates) {
1473
+ if (!isPredicateViolated(predicate, state, undefined)) continue;
1474
+ violatingStates.add(state);
1475
+ onViolated(predicate);
1476
+ }
1477
+ },
1478
+ checkReplayedInitialState: (state, tracing, addFingerprint, onViolated) => {
1479
+ const holdsIn = (
1480
+ covered: CoveredCheck | undefined,
1481
+ expression: Expression,
1482
+ scope: Scope | undefined,
1483
+ ) => holdsReplayed(covered, expression, getContext(tracing, state, undefined, scope));
1484
+ const isInModel = constraintPredicates.every((constraint) =>
1485
+ holdsIn(
1486
+ coveredConstraintChecks.get(constraint.predicate),
1487
+ constraint.predicate,
1488
+ constraint.scope,
1311
1489
  ),
1312
1490
  );
1313
- if (violated.length > 0) violatingStates.add(state);
1314
- return violated;
1315
- },
1316
- checkReplayedInitialState: (state, tracing, addFingerprint) => {
1317
- const holdsIn = (expression: Expression, scope: Scope | undefined) =>
1318
- holdsLikeTlc(expression, getContext(tracing, state, undefined, scope));
1319
- if (constraints.every((constraint) => holdsIn(constraint.predicate, constraint.scope))) {
1320
- addFingerprint();
1491
+ if (isInModel) addFingerprint();
1492
+ for (const invariant of invariantPredicates) {
1493
+ const covered = coveredInvariantChecks.get(invariant.predicate);
1494
+ if (holdsIn(covered, invariant.predicate, invariant.scope)) continue;
1495
+ onViolated({ status: "invariant-violation", name: invariant.name });
1321
1496
  }
1322
- const invariant = invariantPredicates.find((check) => !holdsIn(check.predicate, check.scope));
1323
- if (invariant) return { status: "invariant-violation", name: invariant.name };
1324
1497
  const predicate = properties.initialPredicates.find(
1325
- (check) => !holdsIn(check.expression, check.scope),
1498
+ (check, index) => !holdsIn(coveredInitialPredicates[index], check.expression, check.scope),
1326
1499
  );
1327
- return predicate && { status: "liveness-violation", name: predicate.name };
1500
+ if (predicate) onViolated({ status: "liveness-violation", name: predicate.name });
1328
1501
  },
1329
1502
  checkReplayedSuccessor: (state, next, tracing, addFingerprint) => {
1330
1503
  const isInModel =
1331
- constraints.every((constraint) =>
1332
- holdsLikeTlc(
1504
+ constraintPredicates.every((constraint) =>
1505
+ holdsReplayed(
1506
+ coveredConstraintChecks.get(constraint.predicate),
1333
1507
  constraint.predicate,
1334
1508
  getContext(tracing, next, undefined, constraint.scope),
1335
1509
  ),
1336
1510
  ) &&
1337
- actionConstraints.every((constraint) =>
1338
- holdsLikeTlc(constraint.expression, getContext(tracing, state, next, constraint.scope)),
1511
+ actionConstraints.every((constraint, index) =>
1512
+ holdsReplayed(
1513
+ coveredActionConstraints[index],
1514
+ constraint.expression,
1515
+ getContext(tracing, state, next, constraint.scope),
1516
+ ),
1339
1517
  );
1340
1518
  // TLC checks the invariants of a successor it has not seen, even outside the model.
1341
1519
  const isUnseen = isInModel ? addFingerprint() : true;
1342
1520
  return (
1343
1521
  (!isUnseen ||
1344
1522
  invariantPredicates.every((invariant) =>
1345
- holdsLikeTlc(
1523
+ holdsReplayed(
1524
+ coveredInvariantChecks.get(invariant.predicate),
1346
1525
  invariant.predicate,
1347
1526
  getContext(tracing, next, undefined, invariant.scope),
1348
1527
  ),
1349
1528
  )) &&
1350
- actionProperties.every((property) =>
1351
- holdsLikeTlc(property.box, getContext(tracing, state, next, property.scope)),
1529
+ actionProperties.every((property, index) =>
1530
+ holdsReplayed(
1531
+ coveredActionProperties[index],
1532
+ property.box,
1533
+ getContext(tracing, state, next, property.scope),
1534
+ ),
1352
1535
  )
1353
1536
  );
1354
1537
  },
@@ -1361,31 +1544,32 @@ export const createSearch = (
1361
1544
  ),
1362
1545
  findFailedInitialPredicate,
1363
1546
  findViolatedActionProperty: (state, next) =>
1364
- isCoveredHeld(coveredActionProperties, state, next)
1365
- ? undefined
1366
- : actionProperties.find((property) => {
1367
- try {
1368
- return (
1369
- !holdsLikeTlc(
1370
- property.action,
1371
- getContext(environment, state, next, property.scope),
1372
- () =>
1373
- `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1374
- ) &&
1375
- !holds(
1376
- property.unchanged,
1377
- getContext(environment, state, next, property.scope),
1378
- "a subscript",
1379
- )
1380
- );
1381
- } catch (error) {
1382
- throw withHeadline(
1383
- withNextStateExitCode(error),
1384
- MESSAGE_CODE.actionPropertyEvaluationFailed,
1385
- `Evaluating action property ${property.name} failed.`,
1386
- );
1387
- }
1388
- }),
1547
+ actionProperties.find((property, index) => {
1548
+ const value =
1549
+ coverage && evaluateCovered(coverage, coveredActionProperties[index], state, next);
1550
+ if (typeof value === "boolean") return !value;
1551
+ try {
1552
+ return (
1553
+ !holdsLikeTlc(
1554
+ property.action,
1555
+ getContext(environment, state, next, property.scope),
1556
+ () =>
1557
+ `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1558
+ ) &&
1559
+ !holds(
1560
+ property.unchanged,
1561
+ getContext(environment, state, next, property.scope),
1562
+ "a subscript",
1563
+ )
1564
+ );
1565
+ } catch (error) {
1566
+ throw withHeadline(
1567
+ withNextStateExitCode(error),
1568
+ MESSAGE_CODE.actionPropertyEvaluationFailed,
1569
+ `Evaluating action property ${property.name} failed.`,
1570
+ );
1571
+ }
1572
+ }),
1389
1573
  satisfiesActionConstraints: (state, next) =>
1390
1574
  satisfiesCovered(coveredActionConstraints, state, next) ??
1391
1575
  actionConstraints.every((constraint) => holdsActionConstraint(constraint, state, next)),