tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9

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 (235) 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 +54 -54
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +13 -3
  7. package/dist/index.d.ts +13 -3
  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 +68 -68
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -42
  16. package/dist/run.js +44 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +45 -43
  20. package/dist/transfer.js +45 -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 +11 -1
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +9 -6
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +356 -173
  30. package/src/cli/tlc-output.ts +1 -0
  31. package/src/cli/tlc.ts +4 -3
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +34 -13
  34. package/src/coverage.ts +3 -0
  35. package/src/dependencies.ts +61 -13
  36. package/src/dfid.ts +22 -10
  37. package/src/environment.ts +71 -35
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +149 -54
  40. package/src/exit-codes.ts +29 -15
  41. package/src/instances.ts +16 -6
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +186 -97
  45. package/src/liveness-checker.ts +131 -83
  46. package/src/liveness.ts +52 -11
  47. package/src/obligations/index.ts +1 -1
  48. package/src/obligations/normalize.ts +1 -4
  49. package/src/obligations/printer.ts +5 -5
  50. package/src/obligations/source.ts +2 -0
  51. package/src/parser.ts +115 -145
  52. package/src/prover/isabelle/isar/attrib.ts +4 -4
  53. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  54. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  55. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  56. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  57. package/src/prover/isabelle/pure/term.ts +3 -3
  58. package/src/prover/prep/md5.ts +26 -29
  59. package/src/prover/smt/rewrite.ts +2 -7
  60. package/src/prover/smt/simplify.ts +1 -1
  61. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  62. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  63. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  64. package/src/prover/smt/solver/ast-lt.ts +1 -1
  65. package/src/prover/smt/solver/ast.ts +63 -14
  66. package/src/prover/smt/solver/auf-solver.ts +23 -12
  67. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  68. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  69. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  70. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  71. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  72. package/src/prover/smt/solver/card2bv.ts +35 -18
  73. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  74. package/src/prover/smt/solver/context.ts +67 -13
  75. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  76. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  77. package/src/prover/smt/solver/dependent-expr-state.ts +26 -15
  78. package/src/prover/smt/solver/diff-neq.ts +1 -2
  79. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  80. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  81. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  82. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  83. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  84. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  87. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  88. package/src/prover/smt/solver/euf/mam.ts +1 -5
  89. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  90. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  91. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  92. package/src/prover/smt/solver/factor.ts +36 -14
  93. package/src/prover/smt/solver/fd-solver.ts +148 -39
  94. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  95. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  96. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  97. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  98. package/src/prover/smt/solver/goal.ts +6 -3
  99. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  100. package/src/prover/smt/solver/hashtable.ts +4 -0
  101. package/src/prover/smt/solver/internalizer.ts +1 -1
  102. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  103. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  104. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  105. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  106. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  107. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  108. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  109. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  110. package/src/prover/smt/solver/maxcore.ts +2 -1
  111. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  112. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  113. package/src/prover/smt/solver/model-checker.ts +1 -1
  114. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  115. package/src/prover/smt/solver/model-generator.ts +85 -43
  116. package/src/prover/smt/solver/mpf.ts +2 -4
  117. package/src/prover/smt/solver/mus.ts +2 -3
  118. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  119. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  120. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  121. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  122. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  123. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  124. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  125. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  126. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  127. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  128. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  129. package/src/prover/smt/solver/nlqsat.ts +1 -1
  130. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  131. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  132. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  133. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  134. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  135. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  136. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  137. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  138. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  139. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  140. package/src/prover/smt/solver/nnf.ts +6 -2
  141. package/src/prover/smt/solver/opt-context.ts +21 -7
  142. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  143. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  144. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  145. package/src/prover/smt/solver/opt-solver.ts +10 -6
  146. package/src/prover/smt/solver/optsmt.ts +1 -1
  147. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  148. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  149. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  150. package/src/prover/smt/solver/probes.ts +88 -23
  151. package/src/prover/smt/solver/proto-model.ts +8 -8
  152. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  153. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  154. package/src/prover/smt/solver/qe-lite.ts +2 -2
  155. package/src/prover/smt/solver/qe.ts +3 -2
  156. package/src/prover/smt/solver/qsat.ts +23 -8
  157. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  158. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  159. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  160. package/src/prover/smt/solver/rewriter.ts +31 -25
  161. package/src/prover/smt/solver/rlimit.ts +4 -0
  162. package/src/prover/smt/solver/sat/config.ts +1 -1
  163. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  164. package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
  165. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  166. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  167. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  168. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  169. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  170. package/src/prover/smt/solver/sat/solver.ts +25 -47
  171. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  172. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  173. package/src/prover/smt/solver/seq-derive.ts +2 -2
  174. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  175. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  176. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  177. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  178. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  179. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  180. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  181. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  182. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  183. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  184. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  185. package/src/prover/smt/solver/smt-setup.ts +96 -10
  186. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  187. package/src/prover/smt/solver/smtlib-script.ts +674 -195
  188. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  189. package/src/prover/smt/solver/solver.ts +18 -3
  190. package/src/prover/smt/solver/tactic.ts +332 -189
  191. package/src/prover/smt/solver/theory-bv.ts +13 -3
  192. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  193. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  194. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  195. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  196. package/src/prover/smt/solver/theory-lra.ts +1 -1
  197. package/src/prover/smt/solver/theory-pb.ts +24 -7
  198. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  199. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  200. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  201. package/src/prover/tlapm/cache.ts +8 -8
  202. package/src/prover/zenon/index-table.ts +5 -2
  203. package/src/prover/zenon/isar-case.ts +1 -1
  204. package/src/prover/zenon/isar.ts +2 -2
  205. package/src/prover/zenon/phrase.ts +1 -1
  206. package/src/resolve.ts +1071 -251
  207. package/src/runtime.ts +5 -1
  208. package/src/sany/builtins.ts +10 -10
  209. package/src/sany/generation.ts +2 -13
  210. package/src/sany/generator-definitions.ts +3 -1
  211. package/src/sany/generator-expressions.ts +38 -30
  212. package/src/sany/generator-proofs.ts +6 -3
  213. package/src/sany/generator.ts +2 -1
  214. package/src/sany/lexer.ts +3 -3
  215. package/src/sany/modules.ts +4 -2
  216. package/src/sany/nodes.ts +1 -1
  217. package/src/sany/selectors.ts +11 -6
  218. package/src/sany/xml.ts +2 -3
  219. package/src/search.ts +197 -117
  220. package/src/simulate.ts +165 -102
  221. package/src/spec-description.ts +8 -6
  222. package/src/standard-modules.ts +56 -22
  223. package/src/subexpressions.ts +518 -123
  224. package/src/successors.ts +10 -3
  225. package/src/symmetry.ts +2 -1
  226. package/src/tlc/jar-data.ts +10 -0
  227. package/src/tlc/messages.ts +3 -3
  228. package/src/tlc/random.ts +2 -1
  229. package/src/tlc/replay.ts +27 -14
  230. package/src/tlc/tlc-operators.ts +10 -8
  231. package/src/tlc/tlcext-operators.ts +26 -10
  232. package/src/tlc/trace-spec.ts +9 -22
  233. package/src/typed-tier.ts +44 -27
  234. package/src/typescript/types.ts +2 -2
  235. package/src/values.ts +135 -78
package/src/search.ts CHANGED
@@ -34,7 +34,6 @@ import {
34
34
  type RuntimeInvariant,
35
35
  } from "./environment";
36
36
  import {
37
- isStackOverflow,
38
37
  TlaConfigError,
39
38
  TlaEvaluationError,
40
39
  TlaModuleError,
@@ -53,6 +52,7 @@ import {
53
52
  type Context,
54
53
  type Environment,
55
54
  type Scope,
55
+ type State,
56
56
  } from "./evaluate";
57
57
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
58
58
  import type { JavaOverride } from "./java-overrides";
@@ -86,11 +86,13 @@ import { createTlcOrder } from "./tlc/order";
86
86
  import { getTlcFingerprint, getTlcFingerprints, setFingerprintPolynomial } from "./tlc/fingerprint";
87
87
  import type { TlcVersion } from "./tlc/version";
88
88
  import {
89
+ createModelValue,
89
90
  formatValue,
90
91
  freezeStringOrder,
91
92
  getWrittenPairs,
92
93
  isFunctionValue,
93
94
  isUpdatedElementOf,
95
+ markNormalized,
94
96
  setAliasName,
95
97
  setStringOrder,
96
98
  setValueOptions,
@@ -212,14 +214,7 @@ const isLiteralDefinition = (definition: Definition) =>
212
214
 
213
215
  const getConstantValue = (name: string, definition: Definition, environment: Environment) => {
214
216
  if (environment.constants.has(name)) return environment.constants.get(name);
215
- if (!isConstantLevel(definition, environment) || isLiteralDefinition(definition))
216
- return undefined;
217
- try {
218
- return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
219
- } catch (error) {
220
- if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
221
- throw error;
222
- }
217
+ return isLiteralDefinition(definition) ? undefined : getStartupValue(definition, environment);
223
218
  };
224
219
 
225
220
  const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
@@ -386,12 +381,20 @@ const getSpecification = (
386
381
  let isUntaggedFound = false;
387
382
  expandTemporal(definition.body, undefined, environment, false).forEach((item) => {
388
383
  const conjunct = item.expression;
389
- if (isConstantTrue(item, environment, "spec")) return;
384
+ // TLC takes a state-level definition of the spec whole as an initial predicate.
385
+ const isInitial = item.path.some((name) => {
386
+ const expanded = getDefinition(name, environment);
387
+ return (
388
+ expanded?.kind === "Operator" &&
389
+ getLevel(expanded.body, undefined, environment) === VARIABLE_LEVEL
390
+ );
391
+ });
392
+ if (!isInitial && isConstantTrue(item, environment, "spec")) return;
390
393
  const variableIndex =
391
394
  conjunct.kind === "Identifier" && !isLocallyResolved(conjunct)
392
395
  ? environment.variableIndex.get(conjunct.name)
393
396
  : undefined;
394
- if (conjunct.kind === "Identifier" && variableIndex !== undefined) {
397
+ if (!isInitial && conjunct.kind === "Identifier" && variableIndex !== undefined) {
395
398
  const range = variableLocations[variableIndex].range;
396
399
  throw new TlaConfigError(
397
400
  `The operator ${conjunct.name}, which equals ${range ? formatRange(range) : conjunct.name},\ncannot be used as a spec`,
@@ -656,20 +659,26 @@ const getPredicate = (expression: Expression, environment: Environment) => {
656
659
  };
657
660
 
658
661
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
659
- named.flatMap((item) =>
660
- getConjuncts(item.expression, environment).map((expression) => {
661
- const variables =
662
- item.scope === undefined ? getReadVariables(expression, environment) : undefined;
663
- return {
664
- name: item.name,
665
- expression,
666
- scope: item.scope,
667
- variables,
668
- membership: getMembership(expression, variables, environment),
669
- predicate: getPredicate(item.expression, environment),
670
- };
671
- }),
672
- );
662
+ named.flatMap((item) => {
663
+ const predicate = getPredicate(item.expression, environment);
664
+ const isImpure =
665
+ item.scope === undefined && getReadVariables(predicate, environment) === undefined;
666
+ // TLC evaluates an invariant whole, so one that prints isn't split into conjuncts.
667
+ return (isImpure ? [predicate] : getConjuncts(item.expression, environment)).map(
668
+ (expression) => {
669
+ const variables =
670
+ item.scope === undefined ? getReadVariables(expression, environment) : undefined;
671
+ return {
672
+ name: item.name,
673
+ expression,
674
+ scope: item.scope,
675
+ variables,
676
+ membership: getMembership(expression, variables, environment),
677
+ predicate,
678
+ };
679
+ },
680
+ );
681
+ });
673
682
 
674
683
  const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
675
684
  const variables = stateCheck.variables;
@@ -689,31 +698,42 @@ const isWideConfigValue = (value: ConfigValue): boolean =>
689
698
  ? WIDE_CHARACTER.test(value.value)
690
699
  : value.kind === "Set" && value.elements.some(isWideConfigValue);
691
700
 
692
- const isWideExpression = (expression: Expression): boolean =>
693
- (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
694
- (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
695
- getChildren(expression).some(isWideExpression);
701
+ const isWideExpression = (expression: Expression, checked: Set<Expression>): boolean => {
702
+ if (expression.kind === "Selection") {
703
+ if (checked.has(expression.expression)) return false;
704
+ checked.add(expression.expression);
705
+ }
706
+ return (
707
+ (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
708
+ (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
709
+ getChildren(expression).some((child) => isWideExpression(child, checked))
710
+ );
711
+ };
696
712
 
697
713
  // TLC fingerprints a string by the low byte of each character, so it merges states whose strings differ only above U+00FF.
698
- const hasWideString = (config: ModelConfig, environment: Environment) =>
699
- config.constants.some(
700
- (constant) =>
701
- isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
702
- ) ||
703
- [...environment.definitions.values()].some(
704
- (definition) =>
705
- isWideExpression(definition.body) ||
706
- (definition.kind === "Function" &&
707
- definition.bounds.some((bound) => isWideExpression(bound.set))),
714
+ const hasWideString = (config: ModelConfig, environment: Environment) => {
715
+ const checked = new Set<Expression>();
716
+ return (
717
+ config.constants.some(
718
+ (constant) =>
719
+ isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
720
+ ) ||
721
+ [...environment.definitions.values()].some(
722
+ (definition) =>
723
+ isWideExpression(definition.body, checked) ||
724
+ (definition.kind === "Function" &&
725
+ definition.bounds.some((bound) => isWideExpression(bound.set, checked))),
726
+ )
708
727
  );
728
+ };
709
729
 
710
730
  export interface Search {
711
731
  properties: Properties;
712
732
  toRecord: (state: Value[]) => Record<string, Value>;
713
733
  evaluateAlias: (
714
734
  alias: string,
715
- state: Value[],
716
- next: Value[] | undefined,
735
+ state: State,
736
+ next: State | undefined,
717
737
  isTool: boolean,
718
738
  ) => Record<string, Value>;
719
739
  spec: Specification;
@@ -738,12 +758,13 @@ export interface Search {
738
758
  }
739
759
  | undefined;
740
760
  findViolatedInvariant: (state: Value[], parent?: Value[]) => StateCheck | undefined;
741
- getViolatedInvariants: (state: Value[]) => StateCheck[];
761
+ forEachViolatedInvariant: (state: Value[], onViolated: (invariant: StateCheck) => void) => void;
742
762
  checkReplayedInitialState: (
743
763
  state: Value[],
744
764
  tracing: Environment,
745
765
  addFingerprint: () => void,
746
- ) => Pick<InitialStateViolation, "status" | "name"> | undefined;
766
+ onViolated: (violation: Pick<InitialStateViolation, "status" | "name">) => void,
767
+ ) => void;
747
768
  checkReplayedSuccessor: (
748
769
  state: Value[],
749
770
  next: Value[],
@@ -783,8 +804,8 @@ export const getIncompleteSuccessorMessage = (
783
804
 
784
805
  export const getContext = (
785
806
  environment: Environment,
786
- state: Value[] | undefined,
787
- next: Value[] | undefined,
807
+ state: State | undefined,
808
+ next: State | undefined,
788
809
  scope?: Scope,
789
810
  ) => ({ environment, scope, state, next });
790
811
 
@@ -817,7 +838,7 @@ const getExpectedBoolean = (expression: Expression, environment: Environment) =>
817
838
 
818
839
  const holdsAsConjunct = (check: StateCheck, context: Context) =>
819
840
  holdsLikeTlc(check.expression, context, (expression, environment) => {
820
- holdsLikeTlc(check.predicate, context);
841
+ if (check.predicate !== check.expression) holdsLikeTlc(check.predicate, context);
821
842
  return getExpectedBoolean(expression, environment);
822
843
  });
823
844
 
@@ -1052,8 +1073,20 @@ export const createSearch = (
1052
1073
  ...getCoveredChecks("invariant", configInvariants),
1053
1074
  ...getCoveredChecks("invariant", properties.invariants, false),
1054
1075
  ];
1076
+ const coveredInvariantChecks = new Map(
1077
+ [...configInvariants, ...properties.invariants].map((item, index) => [
1078
+ getPredicate(item.expression, environment),
1079
+ coveredInvariants[index],
1080
+ ]),
1081
+ );
1055
1082
  const coveredActionConstraints = getCoveredChecks("constraint", actionConstraints);
1056
1083
  const coveredConstraints = getCoveredChecks("constraint", namedConstraints);
1084
+ const coveredConstraintChecks = new Map(
1085
+ coveredConstraints.map((check) => [check.expression, check]),
1086
+ );
1087
+ const constraintPredicates = [
1088
+ ...new Map(constraints.map((constraint) => [constraint.predicate, constraint])).values(),
1089
+ ];
1057
1090
  const coveredInitialPredicates = getCoveredChecks("implied", properties.initialPredicates, false);
1058
1091
  const coveredActionProperties = getCoveredChecks(
1059
1092
  "implied",
@@ -1074,9 +1107,14 @@ export const createSearch = (
1074
1107
  return undefined;
1075
1108
  }
1076
1109
  };
1077
- const isCoveredHeld = (checks: CoveredCheck[], state: Value[], next?: Value[]) =>
1078
- coverage !== undefined &&
1079
- checks.every((check) => evaluateCovered(coverage, check, state, next) === true);
1110
+ const holdsReplayed = (
1111
+ covered: CoveredCheck | undefined,
1112
+ expression: Expression,
1113
+ context: Context,
1114
+ ) =>
1115
+ coverage && covered
1116
+ ? runAtCoverageNode(coverage, covered.node, () => holdsLikeTlc(covered.expression, context))
1117
+ : holdsLikeTlc(expression, context);
1080
1118
  const satisfiesCovered = (checks: CoveredCheck[], state: Value[], next?: Value[]) => {
1081
1119
  if (!coverage) return undefined;
1082
1120
  for (const check of checks) {
@@ -1132,9 +1170,15 @@ export const createSearch = (
1132
1170
  };
1133
1171
  const getViewValue = (expression: Expression, state: Value[]) =>
1134
1172
  evaluate(expression, getContext(environment, state, undefined));
1173
+ const getRepresentativeState = (state: Value[]) => {
1174
+ // TLC's TLCStateMut#fingerPrint deep-normalizes a state before it evaluates the view.
1175
+ if (view !== undefined) state.forEach(markNormalized);
1176
+ return symmetryGroup === undefined
1177
+ ? state
1178
+ : getRepresentative(state, symmetryGroup, getTlcOrder());
1179
+ };
1135
1180
  const getTlcStateFingerprint = (state: Value[]) => {
1136
- const representative =
1137
- symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, getTlcOrder());
1181
+ const representative = getRepresentativeState(state);
1138
1182
  return getTlcFingerprint(
1139
1183
  view === undefined
1140
1184
  ? getTlcOrder().map((index) => representative[index])
@@ -1142,15 +1186,16 @@ export const createSearch = (
1142
1186
  );
1143
1187
  };
1144
1188
  const findFailedInitialPredicate = (state: Value[]) =>
1145
- isCoveredHeld(coveredInitialPredicates, state)
1146
- ? undefined
1147
- : properties.initialPredicates.find(
1148
- (predicate) =>
1149
- !holdsLikeTlc(
1150
- predicate.expression,
1151
- getContext(environment, state, undefined, predicate.scope),
1152
- ),
1153
- );
1189
+ properties.initialPredicates.find((predicate, index) => {
1190
+ const value =
1191
+ coverage && evaluateCovered(coverage, coveredInitialPredicates[index], state, undefined);
1192
+ return typeof value === "boolean"
1193
+ ? !value
1194
+ : !holdsLikeTlc(
1195
+ predicate.expression,
1196
+ getContext(environment, state, undefined, predicate.scope),
1197
+ );
1198
+ });
1154
1199
  const violatingStates = new WeakSet<Value[]>();
1155
1200
  const isViolated = (invariant: StateCheck, state: Value[], parent: Value[] | undefined) => {
1156
1201
  const checkedParent = parent && !violatingStates.has(parent) ? parent : undefined;
@@ -1174,6 +1219,21 @@ export const createSearch = (
1174
1219
  );
1175
1220
  }
1176
1221
  };
1222
+ const isPredicateViolated = (
1223
+ predicate: StateCheck,
1224
+ state: Value[],
1225
+ parent: Value[] | undefined,
1226
+ ) => {
1227
+ const covered = coveredInvariantChecks.get(predicate.predicate);
1228
+ const value =
1229
+ coverage && covered ? evaluateCovered(coverage, covered, state, undefined) : undefined;
1230
+ return typeof value === "boolean"
1231
+ ? !value
1232
+ : invariants.some(
1233
+ (invariant) =>
1234
+ invariant.predicate === predicate.predicate && isViolated(invariant, state, parent),
1235
+ );
1236
+ };
1177
1237
  const isFingerprintedLikeTlc = hasWideString(config, environment);
1178
1238
  runtime.getFingerprint = getTlcStateFingerprint;
1179
1239
  const findUnwitnessedPossible = () => {
@@ -1229,14 +1289,16 @@ export const createSearch = (
1229
1289
  spec,
1230
1290
  toRecord,
1231
1291
  evaluateAlias: (alias, state, next, isTool) => {
1292
+ const getStateRecord = () =>
1293
+ toRecord(state.map((value) => value ?? createModelValue("null")));
1232
1294
  try {
1233
1295
  getConfigDefinition("alias", alias, environment);
1234
1296
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
1235
1297
  const record = toAliasRecord(value);
1236
- return record === undefined ? toRecord(state) : setAliasName(record, alias);
1298
+ return record === undefined ? getStateRecord() : setAliasName(record, alias);
1237
1299
  } catch (error) {
1238
1300
  if (!(error instanceof TlaConfigError || error instanceof TlaEvaluationError)) throw error;
1239
- return { ...toRecord(state), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1301
+ return { ...getStateRecord(), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1240
1302
  }
1241
1303
  },
1242
1304
  isSymmetric: symmetryGroup !== undefined,
@@ -1320,64 +1382,81 @@ export const createSearch = (
1320
1382
  },
1321
1383
  getFingerprintState: (state) => {
1322
1384
  if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
1323
- const representative =
1324
- symmetryGroup === undefined
1325
- ? state
1326
- : getRepresentative(state, symmetryGroup, getTlcOrder());
1385
+ const representative = getRepresentativeState(state);
1327
1386
  return view === undefined ? representative : [getViewValue(view.expression, representative)];
1328
1387
  },
1329
1388
  findViolatedInvariant: (state, parent) => {
1330
- const checked = isCoveredHeld(coveredInvariants, state) ? runtimeChecks : invariants;
1331
- const violated = checked.find((invariant) => isViolated(invariant, state, parent));
1389
+ const violated =
1390
+ coverage === undefined
1391
+ ? invariants.find((invariant) => isViolated(invariant, state, parent))
1392
+ : invariantPredicates.find((predicate) => isPredicateViolated(predicate, state, parent));
1332
1393
  if (violated) violatingStates.add(state);
1333
1394
  return violated;
1334
1395
  },
1335
- getViolatedInvariants: (state) => {
1336
- const violated = invariantPredicates.filter((predicate) =>
1337
- invariants.some(
1338
- (invariant) =>
1339
- invariant.predicate === predicate.predicate && isViolated(invariant, state, undefined),
1396
+ forEachViolatedInvariant: (state, onViolated) => {
1397
+ for (const predicate of invariantPredicates) {
1398
+ if (!isPredicateViolated(predicate, state, undefined)) continue;
1399
+ violatingStates.add(state);
1400
+ onViolated(predicate);
1401
+ }
1402
+ },
1403
+ checkReplayedInitialState: (state, tracing, addFingerprint, onViolated) => {
1404
+ const holdsIn = (
1405
+ covered: CoveredCheck | undefined,
1406
+ expression: Expression,
1407
+ scope: Scope | undefined,
1408
+ ) => holdsReplayed(covered, expression, getContext(tracing, state, undefined, scope));
1409
+ const isInModel = constraintPredicates.every((constraint) =>
1410
+ holdsIn(
1411
+ coveredConstraintChecks.get(constraint.predicate),
1412
+ constraint.predicate,
1413
+ constraint.scope,
1340
1414
  ),
1341
1415
  );
1342
- if (violated.length > 0) violatingStates.add(state);
1343
- return violated;
1344
- },
1345
- checkReplayedInitialState: (state, tracing, addFingerprint) => {
1346
- const holdsIn = (expression: Expression, scope: Scope | undefined) =>
1347
- holdsLikeTlc(expression, getContext(tracing, state, undefined, scope));
1348
- if (constraints.every((constraint) => holdsIn(constraint.predicate, constraint.scope))) {
1349
- addFingerprint();
1416
+ if (isInModel) addFingerprint();
1417
+ for (const invariant of invariantPredicates) {
1418
+ const covered = coveredInvariantChecks.get(invariant.predicate);
1419
+ if (holdsIn(covered, invariant.predicate, invariant.scope)) continue;
1420
+ onViolated({ status: "invariant-violation", name: invariant.name });
1350
1421
  }
1351
- const invariant = invariantPredicates.find((check) => !holdsIn(check.predicate, check.scope));
1352
- if (invariant) return { status: "invariant-violation", name: invariant.name };
1353
1422
  const predicate = properties.initialPredicates.find(
1354
- (check) => !holdsIn(check.expression, check.scope),
1423
+ (check, index) => !holdsIn(coveredInitialPredicates[index], check.expression, check.scope),
1355
1424
  );
1356
- return predicate && { status: "liveness-violation", name: predicate.name };
1425
+ if (predicate) onViolated({ status: "liveness-violation", name: predicate.name });
1357
1426
  },
1358
1427
  checkReplayedSuccessor: (state, next, tracing, addFingerprint) => {
1359
1428
  const isInModel =
1360
- constraints.every((constraint) =>
1361
- holdsLikeTlc(
1429
+ constraintPredicates.every((constraint) =>
1430
+ holdsReplayed(
1431
+ coveredConstraintChecks.get(constraint.predicate),
1362
1432
  constraint.predicate,
1363
1433
  getContext(tracing, next, undefined, constraint.scope),
1364
1434
  ),
1365
1435
  ) &&
1366
- actionConstraints.every((constraint) =>
1367
- holdsLikeTlc(constraint.expression, getContext(tracing, state, next, constraint.scope)),
1436
+ actionConstraints.every((constraint, index) =>
1437
+ holdsReplayed(
1438
+ coveredActionConstraints[index],
1439
+ constraint.expression,
1440
+ getContext(tracing, state, next, constraint.scope),
1441
+ ),
1368
1442
  );
1369
1443
  // TLC checks the invariants of a successor it has not seen, even outside the model.
1370
1444
  const isUnseen = isInModel ? addFingerprint() : true;
1371
1445
  return (
1372
1446
  (!isUnseen ||
1373
1447
  invariantPredicates.every((invariant) =>
1374
- holdsLikeTlc(
1448
+ holdsReplayed(
1449
+ coveredInvariantChecks.get(invariant.predicate),
1375
1450
  invariant.predicate,
1376
1451
  getContext(tracing, next, undefined, invariant.scope),
1377
1452
  ),
1378
1453
  )) &&
1379
- actionProperties.every((property) =>
1380
- holdsLikeTlc(property.box, getContext(tracing, state, next, property.scope)),
1454
+ actionProperties.every((property, index) =>
1455
+ holdsReplayed(
1456
+ coveredActionProperties[index],
1457
+ property.box,
1458
+ getContext(tracing, state, next, property.scope),
1459
+ ),
1381
1460
  )
1382
1461
  );
1383
1462
  },
@@ -1390,31 +1469,32 @@ export const createSearch = (
1390
1469
  ),
1391
1470
  findFailedInitialPredicate,
1392
1471
  findViolatedActionProperty: (state, next) =>
1393
- isCoveredHeld(coveredActionProperties, state, next)
1394
- ? undefined
1395
- : actionProperties.find((property) => {
1396
- try {
1397
- return (
1398
- !holdsLikeTlc(
1399
- property.action,
1400
- getContext(environment, state, next, property.scope),
1401
- () =>
1402
- `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1403
- ) &&
1404
- !holds(
1405
- property.unchanged,
1406
- getContext(environment, state, next, property.scope),
1407
- "a subscript",
1408
- )
1409
- );
1410
- } catch (error) {
1411
- throw withHeadline(
1412
- withNextStateExitCode(error),
1413
- MESSAGE_CODE.actionPropertyEvaluationFailed,
1414
- `Evaluating action property ${property.name} failed.`,
1415
- );
1416
- }
1417
- }),
1472
+ actionProperties.find((property, index) => {
1473
+ const value =
1474
+ coverage && evaluateCovered(coverage, coveredActionProperties[index], state, next);
1475
+ if (typeof value === "boolean") return !value;
1476
+ try {
1477
+ return (
1478
+ !holdsLikeTlc(
1479
+ property.action,
1480
+ getContext(environment, state, next, property.scope),
1481
+ () =>
1482
+ `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1483
+ ) &&
1484
+ !holds(
1485
+ property.unchanged,
1486
+ getContext(environment, state, next, property.scope),
1487
+ "a subscript",
1488
+ )
1489
+ );
1490
+ } catch (error) {
1491
+ throw withHeadline(
1492
+ withNextStateExitCode(error),
1493
+ MESSAGE_CODE.actionPropertyEvaluationFailed,
1494
+ `Evaluating action property ${property.name} failed.`,
1495
+ );
1496
+ }
1497
+ }),
1418
1498
  satisfiesActionConstraints: (state, next) =>
1419
1499
  satisfiesCovered(coveredActionConstraints, state, next) ??
1420
1500
  actionConstraints.every((constraint) => holdsActionConstraint(constraint, state, next)),