tla-ts 0.0.4-dev.702eb98 → 0.0.4-dev.7714e32

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 (382) hide show
  1. package/README.md +32 -6
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +27 -27
  5. package/dist/deciders.js +34 -34
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +12 -14
  8. package/dist/index.d.ts +12 -14
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +516 -25
  15. package/dist/prove.js +518 -27
  16. package/dist/run.cjs +45 -0
  17. package/dist/run.js +45 -0
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +76 -86
  21. package/dist/transfer.js +73 -83
  22. package/dist/worker.cjs +6 -6
  23. package/dist/worker.js +6 -6
  24. package/package.json +1 -1
  25. package/src/ast.ts +2 -2
  26. package/src/bags.ts +22 -23
  27. package/src/builtins.ts +16 -8
  28. package/src/check.ts +131 -1154
  29. package/src/{cli-options.ts → cli/options.ts} +54 -9
  30. package/src/cli/run.ts +63 -0
  31. package/src/cli/shared.ts +106 -0
  32. package/src/cli/tlapm.ts +374 -0
  33. package/src/{run-cli.ts → cli/tlc.ts} +112 -761
  34. package/src/cli/xml-exporter.ts +221 -0
  35. package/src/cli.ts +1 -1
  36. package/src/codegen.ts +17 -15
  37. package/src/config.ts +5 -5
  38. package/src/dependencies.ts +4 -6
  39. package/src/environment.ts +55 -60
  40. package/src/errors.ts +12 -36
  41. package/src/evaluate.ts +81 -101
  42. package/src/exit-codes.ts +1 -1
  43. package/src/fingerprints.ts +3 -3
  44. package/src/index.ts +2 -2
  45. package/src/instances.ts +56 -46
  46. package/src/java-overrides.ts +79 -41
  47. package/src/json.ts +31 -36
  48. package/src/levels.ts +10 -13
  49. package/src/{live-check.ts → liveness-checker.ts} +169 -142
  50. package/src/liveness.ts +38 -34
  51. package/src/obligations/action.ts +58 -105
  52. package/src/obligations/{anon.ts → anonymize.ts} +44 -52
  53. package/src/obligations/equality.ts +260 -0
  54. package/src/obligations/expression.ts +42 -530
  55. package/src/obligations/format.ts +7 -8
  56. package/src/obligations/generate.ts +93 -783
  57. package/src/obligations/index.ts +23 -23
  58. package/src/obligations/levels.ts +38 -44
  59. package/src/obligations/module.ts +106 -729
  60. package/src/obligations/normalize.ts +554 -0
  61. package/src/obligations/operators.ts +176 -0
  62. package/src/obligations/pragma.ts +35 -29
  63. package/src/obligations/printer.ts +98 -209
  64. package/src/obligations/proof.ts +0 -1
  65. package/src/obligations/regroup.ts +100 -0
  66. package/src/obligations/simplify.ts +668 -0
  67. package/src/obligations/source.ts +92 -192
  68. package/src/obligations/{deref.ts → subexpression.ts} +82 -113
  69. package/src/obligations/substitution.ts +261 -0
  70. package/src/obligations/temporal.ts +32 -30
  71. package/src/obligations/tuples.ts +37 -53
  72. package/src/parallel-worker.ts +37 -33
  73. package/src/parallel.ts +30 -24
  74. package/src/parser.ts +67 -74
  75. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  76. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  77. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  78. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  79. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  80. package/src/{prove → prover}/decide-pool.ts +14 -19
  81. package/src/{prove → prover}/deciders.ts +7 -1
  82. package/src/{obligations/pickle.ts → prover/first-order.ts} +79 -4
  83. package/src/{prove → prover}/isabelle/decide.ts +3 -6
  84. package/src/{prove → prover}/isabelle/encode.ts +106 -138
  85. package/src/{prove → prover}/isabelle/isar/inner-syntax.ts +1 -1
  86. package/src/{prove → prover}/isabelle/isar/method.ts +3 -3
  87. package/src/{prove → prover}/isabelle/isar/type-check.ts +1 -1
  88. package/src/{prove → prover}/isabelle/provers/blast/blast.ts +1 -1
  89. package/src/{prove → prover}/isabelle/provers/blast/branch.ts +1 -1
  90. package/src/{prove → prover}/isabelle/provers/blast/term.ts +3 -4
  91. package/src/{prove → prover}/isabelle/provers/clasimp.ts +1 -1
  92. package/src/{prove → prover}/isabelle/provers/classical.ts +3 -3
  93. package/src/{prove → prover}/isabelle/provers/hypsubst.ts +1 -9
  94. package/src/{prove → prover}/isabelle/pure/conv.ts +1 -1
  95. package/src/{prove → prover}/isabelle/pure/drule.ts +2 -2
  96. package/src/{prove → prover}/isabelle/pure/envir.ts +3 -35
  97. package/src/{prove → prover}/isabelle/pure/logic.ts +4 -76
  98. package/src/{prove → prover}/isabelle/pure/name.ts +1 -13
  99. package/src/{prove → prover}/isabelle/pure/net.ts +2 -49
  100. package/src/{prove → prover}/isabelle/pure/pattern.ts +3 -22
  101. package/src/{prove → prover}/isabelle/pure/raw-simplifier.ts +3 -18
  102. package/src/{prove → prover}/isabelle/pure/seq.ts +0 -23
  103. package/src/{prove → prover}/isabelle/pure/simplifier.ts +2 -8
  104. package/src/{prove → prover}/isabelle/pure/table.ts +1 -8
  105. package/src/{prove → prover}/isabelle/pure/tactic.ts +5 -113
  106. package/src/{prove → prover}/isabelle/pure/tactical.ts +1 -84
  107. package/src/{prove → prover}/isabelle/pure/term-ord.ts +1 -55
  108. package/src/{prove → prover}/isabelle/pure/term.ts +8 -128
  109. package/src/{prove → prover}/isabelle/pure/thm.ts +4 -27
  110. package/src/{prove → prover}/isabelle/pure/type.ts +0 -12
  111. package/src/{prove → prover}/isabelle/pure/unify.ts +1 -1
  112. package/src/{prove → prover}/isabelle/tla/classical-setup.ts +1 -1
  113. package/src/{prove → prover}/ocaml.ts +1 -1
  114. package/src/{prove → prover}/prep/action.ts +54 -66
  115. package/src/{prove → prover}/prep/enabled-axioms.ts +2 -2
  116. package/src/{prove → prover}/prep/fingerprint.ts +3 -3
  117. package/src/{prove → prover}/prep/level-comparison.ts +15 -38
  118. package/src/{prove → prover}/prep/md5.ts +2 -9
  119. package/src/{prove/prep/pragma.ts → prover/prep/methods.ts} +4 -4
  120. package/src/prover/prep/normalize.ts +309 -0
  121. package/src/{prove → prover}/prove-worker.ts +4 -11
  122. package/src/prover/prove.ts +492 -0
  123. package/src/{prove → prover}/ptl/encode.ts +19 -31
  124. package/src/{prove → prover}/smt/axioms.ts +78 -79
  125. package/src/{prove → prover}/smt/data.ts +16 -45
  126. package/src/{prove → prover}/smt/encode.ts +134 -28
  127. package/src/{prove → prover}/smt/extensionality.ts +14 -12
  128. package/src/{prove → prover}/smt/flatten.ts +3 -18
  129. package/src/{prove → prover}/smt/format.ts +14 -3
  130. package/src/{prove → prover}/smt/instances.ts +4 -5
  131. package/src/{prove → prover}/smt/rewrite.ts +41 -59
  132. package/src/{prove → prover}/smt/solver/ast-util.ts +0 -56
  133. package/src/{prove → prover}/smt/solver/case-split-queue.ts +1 -1
  134. package/src/{prove → prover}/smt/solver/enode.ts +1 -1
  135. package/src/{prove → prover}/smt/solver/lp/dep-intervals.ts +0 -14
  136. package/src/{prove → prover}/smt/solver/model-macro-solver.ts +1 -1
  137. package/src/{prove → prover}/smt/solver/nlsat/algebraic.ts +3 -3
  138. package/src/{prove → prover}/smt/solver/nlsat/atoms.ts +1 -1
  139. package/src/{prove → prover}/smt/solver/nlsat/explain.ts +1 -1
  140. package/src/{prove → prover}/smt/solver/nlsat/interval-set.ts +1 -1
  141. package/src/{prove → prover}/smt/solver/nlsat/levelwise.ts +4 -7
  142. package/src/{prove → prover}/smt/solver/nlsat/polynomial.ts +4 -4
  143. package/src/{prove → prover}/smt/solver/nlsat/upolynomial.ts +2 -2
  144. package/src/{prove → prover}/smt/solver/pattern-inference.ts +1 -1
  145. package/src/{prove → prover}/smt/solver/relevancy.ts +2 -2
  146. package/src/{prove → prover}/smt/solver/rewriter.ts +1 -1
  147. package/src/{prove → prover}/smt/solver/solver.ts +2 -2
  148. package/src/prover/tlapm/cache.ts +236 -0
  149. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  150. package/src/{prove → prover}/tlapm/tlapm.ts +1 -2
  151. package/src/prover/verdict.ts +13 -0
  152. package/src/{prove → prover}/zenon/decide.ts +5 -11
  153. package/src/{prove → prover}/zenon/encode.ts +40 -106
  154. package/src/{prove → prover}/zenon/eqrel.ts +1 -1
  155. package/src/{prove → prover}/zenon/equality-rules.ts +1 -1
  156. package/src/{prove → prover}/zenon/expr.ts +2 -2
  157. package/src/{prove → prover}/zenon/index-table.ts +1 -1
  158. package/src/{prove → prover}/zenon/isar.ts +1 -1
  159. package/src/{prove → prover}/zenon/llproof.ts +1 -1
  160. package/src/{prove → prover}/zenon/mltoll.ts +1 -1
  161. package/src/{prove → prover}/zenon/node.ts +1 -1
  162. package/src/{prove → prover}/zenon/search.ts +1 -1
  163. package/src/{prove → prover}/zenon/tla/terms.ts +1 -20
  164. package/src/{prove → prover}/zenon/tla/tla.ts +1 -1
  165. package/src/randomization.ts +19 -24
  166. package/src/resolve.ts +15 -22
  167. package/src/runtime.ts +8 -8
  168. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  169. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  170. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  171. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  172. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  173. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  174. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  175. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  176. package/src/{sany-report.ts → sany/report.ts} +16 -17
  177. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  178. package/src/{sany-source.ts → sany/source.ts} +6 -7
  179. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  180. package/src/search.ts +969 -0
  181. package/src/spec-description.ts +26 -20
  182. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  183. package/src/standard-modules.ts +16 -20
  184. package/src/state-graph.ts +9 -8
  185. package/src/substitution-levels.ts +2 -2
  186. package/src/successors.ts +16 -19
  187. package/src/symmetry.ts +1 -1
  188. package/src/tableau.ts +6 -7
  189. package/src/tlc/fingerprint.ts +214 -0
  190. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  191. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  192. package/src/{tlc-random.ts → tlc/random.ts} +3 -213
  193. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  194. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  195. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  196. package/src/transfer.ts +32 -32
  197. package/src/values.ts +72 -67
  198. package/src/worker.ts +1 -4
  199. package/dist/run-cli.cjs +0 -38
  200. package/dist/run-cli.js +0 -38
  201. package/src/canonical.ts +0 -40
  202. package/src/obligations/ctx.ts +0 -64
  203. package/src/prove/prep/defs.ts +0 -27
  204. package/src/prove/prep/elab.ts +0 -156
  205. package/src/prove/prep/enabled.ts +0 -43
  206. package/src/prove/prep/flatten.ts +0 -70
  207. package/src/prove/prep/trivial.ts +0 -22
  208. package/src/prove/prove.ts +0 -417
  209. package/src/prove/smt/axiomatize.ts +0 -69
  210. package/src/prove/smt/simplify.ts +0 -57
  211. package/src/prove/verdict.ts +0 -13
  212. package/src/standard-ranges.ts +0 -116
  213. package/src/value-sources.ts +0 -29
  214. /package/src/{prove → prover}/isabelle/LICENSE +0 -0
  215. /package/src/{prove → prover}/isabelle/LICENSE-tlapm +0 -0
  216. /package/src/{prove → prover}/isabelle/isar/proof.ts +0 -0
  217. /package/src/{prove → prover}/isabelle/isar/statement.ts +0 -0
  218. /package/src/{prove → prover}/isabelle/isar/theory.ts +0 -0
  219. /package/src/{prove → prover}/isabelle/provers/blast/prove.ts +0 -0
  220. /package/src/{prove → prover}/isabelle/provers/blast/rules.ts +0 -0
  221. /package/src/{prove → prover}/isabelle/provers/blast/state.ts +0 -0
  222. /package/src/{prove → prover}/isabelle/pure/bicompose.ts +0 -0
  223. /package/src/{prove → prover}/isabelle/pure/consts.ts +0 -0
  224. /package/src/{prove → prover}/isabelle/pure/goal.ts +0 -0
  225. /package/src/{prove → prover}/isabelle/pure/interrupt.ts +0 -0
  226. /package/src/{prove → prover}/isabelle/pure/list.ts +0 -0
  227. /package/src/{prove → prover}/isabelle/pure/object-logic.ts +0 -0
  228. /package/src/{prove → prover}/isabelle/pure/rewriter.ts +0 -0
  229. /package/src/{prove → prover}/isabelle/pure/search.ts +0 -0
  230. /package/src/{prove → prover}/isabelle/pure/variable.ts +0 -0
  231. /package/src/{prove → prover}/isabelle/tla/context.ts +0 -0
  232. /package/src/{prove → prover}/isabelle/tla/logic-data.ts +0 -0
  233. /package/src/{prove → prover}/isabelle/tla/logic.ts +0 -0
  234. /package/src/{prove → prover}/isabelle/tla/simpdata.ts +0 -0
  235. /package/src/{prove → prover}/isabelle/tools/intuitionistic.ts +0 -0
  236. /package/src/{prove → prover}/ptl/decide.ts +0 -0
  237. /package/src/{prove → prover}/ptl/sat.ts +0 -0
  238. /package/src/{prove → prover}/ptl/tableau.ts +0 -0
  239. /package/src/{prove → prover}/smt/context.ts +0 -0
  240. /package/src/{prove → prover}/smt/solver/act-cache.ts +0 -0
  241. /package/src/{prove → prover}/smt/solver/arith-rewriter.ts +0 -0
  242. /package/src/{prove → prover}/smt/solver/array.ts +0 -0
  243. /package/src/{prove → prover}/smt/solver/asserted-formulas.ts +0 -0
  244. /package/src/{prove → prover}/smt/solver/ast-lt.ts +0 -0
  245. /package/src/{prove → prover}/smt/solver/ast.ts +0 -0
  246. /package/src/{prove → prover}/smt/solver/auf-solver.ts +0 -0
  247. /package/src/{prove → prover}/smt/solver/cg-table.ts +0 -0
  248. /package/src/{prove → prover}/smt/solver/clause.ts +0 -0
  249. /package/src/{prove → prover}/smt/solver/conflict-resolution.ts +0 -0
  250. /package/src/{prove → prover}/smt/solver/context.ts +0 -0
  251. /package/src/{prove → prover}/smt/solver/ctx-simplify.ts +0 -0
  252. /package/src/{prove → prover}/smt/solver/der.ts +0 -0
  253. /package/src/{prove → prover}/smt/solver/dyn-ack.ts +0 -0
  254. /package/src/{prove → prover}/smt/solver/e-matching.ts +0 -0
  255. /package/src/{prove → prover}/smt/solver/expr-ref.ts +0 -0
  256. /package/src/{prove → prover}/smt/solver/expr-safe-replace.ts +0 -0
  257. /package/src/{prove → prover}/smt/solver/fingerprints.ts +0 -0
  258. /package/src/{prove → prover}/smt/solver/flat-literals.ts +0 -0
  259. /package/src/{prove → prover}/smt/solver/goal.ts +0 -0
  260. /package/src/{prove → prover}/smt/solver/hash.ts +0 -0
  261. /package/src/{prove → prover}/smt/solver/hashtable.ts +0 -0
  262. /package/src/{prove → prover}/smt/solver/internalizer.ts +0 -0
  263. /package/src/{prove → prover}/smt/solver/lbool.ts +0 -0
  264. /package/src/{prove → prover}/smt/solver/literal.ts +0 -0
  265. /package/src/{prove → prover}/smt/solver/lp/bound-propagator.ts +0 -0
  266. /package/src/{prove → prover}/smt/solver/lp/constraints.ts +0 -0
  267. /package/src/{prove → prover}/smt/solver/lp/containers.ts +0 -0
  268. /package/src/{prove → prover}/smt/solver/lp/core-solver.ts +0 -0
  269. /package/src/{prove → prover}/smt/solver/lp/cross-nested.ts +0 -0
  270. /package/src/{prove → prover}/smt/solver/lp/dependency.ts +0 -0
  271. /package/src/{prove → prover}/smt/solver/lp/dioph-eq.ts +0 -0
  272. /package/src/{prove → prover}/smt/solver/lp/explanation.ts +0 -0
  273. /package/src/{prove → prover}/smt/solver/lp/gomory.ts +0 -0
  274. /package/src/{prove → prover}/smt/solver/lp/hnf-cutter.ts +0 -0
  275. /package/src/{prove → prover}/smt/solver/lp/hnf.ts +0 -0
  276. /package/src/{prove → prover}/smt/solver/lp/int-cube.ts +0 -0
  277. /package/src/{prove → prover}/smt/solver/lp/int-solver.ts +0 -0
  278. /package/src/{prove → prover}/smt/solver/lp/lar-solver.ts +0 -0
  279. /package/src/{prove → prover}/smt/solver/lp/lar-term.ts +0 -0
  280. /package/src/{prove → prover}/smt/solver/lp/lp-settings.ts +0 -0
  281. /package/src/{prove → prover}/smt/solver/lp/maximize-term.ts +0 -0
  282. /package/src/{prove → prover}/smt/solver/lp/nex-creator.ts +0 -0
  283. /package/src/{prove → prover}/smt/solver/lp/nex.ts +0 -0
  284. /package/src/{prove → prover}/smt/solver/lp/nla-backoff.ts +0 -0
  285. /package/src/{prove → prover}/smt/solver/lp/nla-basics.ts +0 -0
  286. /package/src/{prove → prover}/smt/solver/lp/nla-core.ts +0 -0
  287. /package/src/{prove → prover}/smt/solver/lp/nla-divisions.ts +0 -0
  288. /package/src/{prove → prover}/smt/solver/lp/nla-emonics.ts +0 -0
  289. /package/src/{prove → prover}/smt/solver/lp/nla-factorization.ts +0 -0
  290. /package/src/{prove → prover}/smt/solver/lp/nla-grobner.ts +0 -0
  291. /package/src/{prove → prover}/smt/solver/lp/nla-horner.ts +0 -0
  292. /package/src/{prove → prover}/smt/solver/lp/nla-intervals.ts +0 -0
  293. /package/src/{prove → prover}/smt/solver/lp/nla-monomial-bounds.ts +0 -0
  294. /package/src/{prove → prover}/smt/solver/lp/nla-monotone.ts +0 -0
  295. /package/src/{prove → prover}/smt/solver/lp/nla-order.ts +0 -0
  296. /package/src/{prove → prover}/smt/solver/lp/nla-patcher.ts +0 -0
  297. /package/src/{prove → prover}/smt/solver/lp/nla-tangents.ts +0 -0
  298. /package/src/{prove → prover}/smt/solver/lp/nla-throttle.ts +0 -0
  299. /package/src/{prove → prover}/smt/solver/lp/nla-types.ts +0 -0
  300. /package/src/{prove → prover}/smt/solver/lp/nla-var-eqs.ts +0 -0
  301. /package/src/{prove → prover}/smt/solver/lp/nra-solver.ts +0 -0
  302. /package/src/{prove → prover}/smt/solver/lp/numeric-pair.ts +0 -0
  303. /package/src/{prove → prover}/smt/solver/lp/pdd-interval.ts +0 -0
  304. /package/src/{prove → prover}/smt/solver/lp/pdd-simplifier.ts +0 -0
  305. /package/src/{prove → prover}/smt/solver/lp/pdd-solver.ts +0 -0
  306. /package/src/{prove → prover}/smt/solver/lp/pdd.ts +0 -0
  307. /package/src/{prove → prover}/smt/solver/lp/random-updater.ts +0 -0
  308. /package/src/{prove → prover}/smt/solver/lp/static-matrix.ts +0 -0
  309. /package/src/{prove → prover}/smt/solver/lp/union-find.ts +0 -0
  310. /package/src/{prove → prover}/smt/solver/mam-compiler.ts +0 -0
  311. /package/src/{prove → prover}/smt/solver/mam-interpreter.ts +0 -0
  312. /package/src/{prove → prover}/smt/solver/maximize-ac-sharing.ts +0 -0
  313. /package/src/{prove → prover}/smt/solver/model-checker.ts +0 -0
  314. /package/src/{prove → prover}/smt/solver/model-evaluator.ts +0 -0
  315. /package/src/{prove → prover}/smt/solver/model-finder.ts +0 -0
  316. /package/src/{prove → prover}/smt/solver/model-generator.ts +0 -0
  317. /package/src/{prove → prover}/smt/solver/nlsat/evaluator.ts +0 -0
  318. /package/src/{prove → prover}/smt/solver/nlsat/mpbq.ts +0 -0
  319. /package/src/{prove → prover}/smt/solver/nlsat/solver.ts +0 -0
  320. /package/src/{prove → prover}/smt/solver/nlsat/types.ts +0 -0
  321. /package/src/{prove → prover}/smt/solver/nlsat/upolynomial-factorization.ts +0 -0
  322. /package/src/{prove → prover}/smt/solver/nnf.ts +0 -0
  323. /package/src/{prove → prover}/smt/solver/poly-rewriter.ts +0 -0
  324. /package/src/{prove → prover}/smt/solver/propagate-values.ts +0 -0
  325. /package/src/{prove → prover}/smt/solver/proto-model.ts +0 -0
  326. /package/src/{prove → prover}/smt/solver/pull-quant.ts +0 -0
  327. /package/src/{prove → prover}/smt/solver/qe-lite-der.ts +0 -0
  328. /package/src/{prove → prover}/smt/solver/qe-lite-fm.ts +0 -0
  329. /package/src/{prove → prover}/smt/solver/qe-lite.ts +0 -0
  330. /package/src/{prove → prover}/smt/solver/qi-queue.ts +0 -0
  331. /package/src/{prove → prover}/smt/solver/quant-tactics.ts +0 -0
  332. /package/src/{prove → prover}/smt/solver/quantifier-analyzer.ts +0 -0
  333. /package/src/{prove → prover}/smt/solver/quantifier-manager.ts +0 -0
  334. /package/src/{prove → prover}/smt/solver/random-gen.ts +0 -0
  335. /package/src/{prove → prover}/smt/solver/rational.ts +0 -0
  336. /package/src/{prove → prover}/smt/solver/ref-vector.ts +0 -0
  337. /package/src/{prove → prover}/smt/solver/rewriter-tpl.ts +0 -0
  338. /package/src/{prove → prover}/smt/solver/rlimit.ts +0 -0
  339. /package/src/{prove → prover}/smt/solver/smtlib-parser.ts +0 -0
  340. /package/src/{prove → prover}/smt/solver/sort.ts +0 -0
  341. /package/src/{prove → prover}/smt/solver/sticky-generations.ts +0 -0
  342. /package/src/{prove → prover}/smt/solver/theory-lra-axioms.ts +0 -0
  343. /package/src/{prove → prover}/smt/solver/theory-lra-bounds.ts +0 -0
  344. /package/src/{prove → prover}/smt/solver/theory-lra-final-check.ts +0 -0
  345. /package/src/{prove → prover}/smt/solver/theory-lra-internalize.ts +0 -0
  346. /package/src/{prove → prover}/smt/solver/theory-lra-model.ts +0 -0
  347. /package/src/{prove → prover}/smt/solver/theory-lra-propagate.ts +0 -0
  348. /package/src/{prove → prover}/smt/solver/theory-lra-state.ts +0 -0
  349. /package/src/{prove → prover}/smt/solver/theory-lra.ts +0 -0
  350. /package/src/{prove → prover}/smt/solver/var-subst.ts +0 -0
  351. /package/src/{prove → prover}/smt/solver/z3-license.txt +0 -0
  352. /package/src/{prove → prover}/smt/table.ts +0 -0
  353. /package/src/{prove → prover}/tlaps-module.ts +0 -0
  354. /package/src/{prove → prover}/zenon/LICENSE +0 -0
  355. /package/src/{prove → prover}/zenon/check/check.ts +0 -0
  356. /package/src/{prove → prover}/zenon/check/definitions.ts +0 -0
  357. /package/src/{prove → prover}/zenon/check/equality.ts +0 -0
  358. /package/src/{prove → prover}/zenon/check/functions.ts +0 -0
  359. /package/src/{prove → prover}/zenon/check/keys.ts +0 -0
  360. /package/src/{prove → prover}/zenon/check/propositional.ts +0 -0
  361. /package/src/{prove → prover}/zenon/check/records.ts +0 -0
  362. /package/src/{prove → prover}/zenon/check/relations.ts +0 -0
  363. /package/src/{prove → prover}/zenon/check/rewrites.ts +0 -0
  364. /package/src/{prove → prover}/zenon/check/sets.ts +0 -0
  365. /package/src/{prove → prover}/zenon/check/terms.ts +0 -0
  366. /package/src/{prove → prover}/zenon/check/tla.ts +0 -0
  367. /package/src/{prove → prover}/zenon/isar-case.ts +0 -0
  368. /package/src/{prove → prover}/zenon/limits.ts +0 -0
  369. /package/src/{prove → prover}/zenon/ocaml.ts +0 -0
  370. /package/src/{prove → prover}/zenon/parse.ts +0 -0
  371. /package/src/{prove → prover}/zenon/phrase.ts +0 -0
  372. /package/src/{prove → prover}/zenon/proof.ts +0 -0
  373. /package/src/{prove → prover}/zenon/propositional-rules.ts +0 -0
  374. /package/src/{prove → prover}/zenon/rules.ts +0 -0
  375. /package/src/{prove → prover}/zenon/tla/functions.ts +0 -0
  376. /package/src/{prove → prover}/zenon/tla/llproof.ts +0 -0
  377. /package/src/{prove → prover}/zenon/tla/records.ts +0 -0
  378. /package/src/{prove → prover}/zenon/tla/rewrites.ts +0 -0
  379. /package/src/{prove → prover}/zenon/tla/sets.ts +0 -0
  380. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  381. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
  382. /package/src/{tlc-version.ts → tlc/version.ts} +0 -0
@@ -16,13 +16,25 @@ import {
16
16
  SEQ,
17
17
  tla,
18
18
  } from "./format";
19
- import { axiom, TYPED_SYMBOLS, type Axiom, type AxiomArgument } from "./table";
19
+ import { axiom, TYPED_SYMBOLS, type AxiomArgument } from "./table";
20
20
 
21
- export const getTyping = (name: string, operator: string, arity: number, isGuarded = false) => {
22
- const symbol = tla(name);
23
- const variables = arity === 1 ? ["x1"] : isGuarded ? ["x", "y"] : ["x1", "x2"];
21
+ // The arithmetic symbols with a Typing axiom: each one's SMT-LIB operator and arity.
22
+ export const TYPED_OPERATORS: Record<string, [string, number]> = {
23
+ IntPlus: ["+", 2],
24
+ IntMinus: ["-", 2],
25
+ IntTimes: ["*", 2],
26
+ IntUminus: ["-", 1],
27
+ IntQuotient: ["div", 2],
28
+ IntRemainder: ["mod", 2],
29
+ IntLteq: ["<=", 2],
30
+ };
31
+
32
+ export const getTyping = (name: string) => {
33
+ const operator = TYPED_OPERATORS[name][0];
34
+ const isGuarded = operator === "div" || operator === "mod";
35
+ const variables = TYPED_OPERATORS[name][1] === 1 ? ["x1"] : isGuarded ? ["x", "y"] : ["x1", "x2"];
24
36
  const left = call(
25
- symbol,
37
+ tla(name),
26
38
  variables.map((variable) => `(${CAST_INT} ${variable})`),
27
39
  );
28
40
  const right =
@@ -38,16 +50,6 @@ export const getTyping = (name: string, operator: string, arity: number, isGuard
38
50
  );
39
51
  };
40
52
 
41
- export const TYPINGS: Record<string, () => Axiom> = {
42
- IntPlus: () => getTyping("IntPlus", "+", 2),
43
- IntMinus: () => getTyping("IntMinus", "-", 2),
44
- IntTimes: () => getTyping("IntTimes", "*", 2),
45
- IntUminus: () => getTyping("IntUminus", "-", 1),
46
- IntQuotient: () => getTyping("IntQuotient", "div", 2, true),
47
- IntRemainder: () => getTyping("IntRemainder", "mod", 2, true),
48
- IntLteq: () => getTyping("IntLteq", "<=", 2),
49
- };
50
-
51
53
  export const getEnumeration = (count: number) => {
52
54
  const symbol = tla(`SetEnum_${count}`);
53
55
  const elements = getNames("a", count);
@@ -75,53 +77,76 @@ export const getEnumeration = (count: number) => {
75
77
  export const getIntegers = (count: number) =>
76
78
  Array.from({ length: count }, (_value, index) => `(${CAST_INT} ${index + 1})`);
77
79
 
80
+ export const getFieldKeys = (fields: string[]) => fields.map((field) => tla(`StrLit_${field}`));
81
+
78
82
  // TupExcept and RecExcept: updating one component of a tuple or record.
79
- export const getComponentExcept = (
80
- name: string,
83
+ const getComponentExcepts = (
84
+ prefix: string,
81
85
  args: AxiomArgument[],
82
86
  symbol: string,
83
87
  keys: string[],
84
- index: number,
85
88
  ) => {
86
89
  const elements = getNames("x", keys.length);
87
- const updated = `(${FUN_EXCEPT} ${call(symbol, elements)} ${keys[index]} x)`;
88
- const replaced = elements.map((element, position) => (position === index ? "x" : element));
89
- return axiom(
90
- name,
91
- [...args, index + 1],
92
- forall([...elements, "x"], `(= ${updated} ${call(symbol, replaced)})`, [[updated]]),
90
+ return keys.map((key, index) => {
91
+ const updated = `(${FUN_EXCEPT} ${call(symbol, elements)} ${key} x)`;
92
+ const replaced = elements.map((element, position) => (position === index ? "x" : element));
93
+ return axiom(
94
+ `${prefix}Except`,
95
+ [...args, index + 1],
96
+ forall([...elements, "x"], `(= ${updated} ${call(symbol, replaced)})`, [[updated]]),
97
+ );
98
+ });
99
+ };
100
+
101
+ export const getTupleExcepts = (count: number) =>
102
+ getComponentExcepts("Tup", [count], tla(`Tuple_${count}`), getIntegers(count));
103
+
104
+ export const getRecordExcepts = (fields: string[]) =>
105
+ getComponentExcepts("Rec", [fields], tla(`Record_${fields.join("_")}`), getFieldKeys(fields));
106
+
107
+ // TupIsafcn, TupDomDef and TupAppDef, or their Rec counterparts: a tuple or record is the
108
+ // function from its keys to its components. The empty tuple has no domain or components to define.
109
+ const getComponentFunction = (
110
+ prefix: string,
111
+ args: AxiomArgument[],
112
+ symbol: string,
113
+ keys: string[],
114
+ ) => {
115
+ const elements = getNames("x", keys.length);
116
+ const value = call(symbol, elements);
117
+ const isafcn = axiom(
118
+ `${prefix}Isafcn`,
119
+ args,
120
+ forall(elements, `(${FUN_ISAFCN} ${value})`, [[value]]),
93
121
  );
122
+ if (keys.length === 0) return [isafcn];
123
+ return [
124
+ isafcn,
125
+ axiom(
126
+ `${prefix}DomDef`,
127
+ args,
128
+ forall(elements, `(= (${FUN_DOM} ${value}) ${call(tla(`SetEnum_${keys.length}`), keys)})`, [
129
+ [value],
130
+ ]),
131
+ ),
132
+ axiom(
133
+ `${prefix}AppDef`,
134
+ args,
135
+ forall(
136
+ elements,
137
+ conjoin(keys.map((key, index) => `(= (${FUN_APP} ${value} ${key}) ${elements[index]})`)),
138
+ [[value]],
139
+ ),
140
+ ),
141
+ ];
94
142
  };
95
143
 
96
144
  export const getTupleAxioms = (count: number, isExcept: boolean) => {
97
145
  const symbol = tla(`Tuple_${count}`);
98
146
  const elements = getNames("x", count);
99
147
  const value = call(symbol, elements);
100
- const keys = getIntegers(count);
101
148
  return [
102
- axiom("TupIsafcn", [count], forall(elements, `(${FUN_ISAFCN} ${value})`, [[value]])),
103
- ...(count === 0
104
- ? []
105
- : [
106
- axiom(
107
- "TupDomDef",
108
- [count],
109
- forall(elements, `(= (${FUN_DOM} ${value}) ${call(tla(`SetEnum_${count}`), keys)})`, [
110
- [value],
111
- ]),
112
- ),
113
- axiom(
114
- "TupAppDef",
115
- [count],
116
- forall(
117
- elements,
118
- conjoin(
119
- keys.map((key, index) => `(= (${FUN_APP} ${value} ${key}) ${elements[index]})`),
120
- ),
121
- [[value]],
122
- ),
123
- ),
124
- ]),
149
+ ...getComponentFunction("Tup", [count], symbol, getIntegers(count)),
125
150
  axiom(
126
151
  "SeqTupTyping",
127
152
  [count],
@@ -138,40 +163,14 @@ export const getTupleAxioms = (count: number, isExcept: boolean) => {
138
163
  [count],
139
164
  forall(elements, `(= (${LEN} ${value}) (${CAST_INT} ${count}))`, [[value]]),
140
165
  ),
141
- ...(isExcept
142
- ? keys.map((_key, index) => getComponentExcept("TupExcept", [count], symbol, keys, index))
143
- : []),
166
+ ...(isExcept ? getTupleExcepts(count) : []),
144
167
  ];
145
168
  };
146
169
 
147
- export const getRecordAxioms = (fields: string[], isExcept: boolean) => {
148
- const symbol = tla(`Record_${fields.join("_")}`);
149
- const keys = fields.map((field) => tla(`StrLit_${field}`));
150
- const elements = getNames("x", fields.length);
151
- const value = call(symbol, elements);
152
- return [
153
- axiom("RecIsafcn", [fields], forall(elements, `(${FUN_ISAFCN} ${value})`, [[value]])),
154
- axiom(
155
- "RecDomDef",
156
- [fields],
157
- forall(elements, `(= (${FUN_DOM} ${value}) ${call(tla(`SetEnum_${fields.length}`), keys)})`, [
158
- [value],
159
- ]),
160
- ),
161
- axiom(
162
- "RecAppDef",
163
- [fields],
164
- forall(
165
- elements,
166
- conjoin(keys.map((key, index) => `(= (${FUN_APP} ${value} ${key}) ${elements[index]})`)),
167
- [[value]],
168
- ),
169
- ),
170
- ...(isExcept
171
- ? keys.map((_key, index) => getComponentExcept("RecExcept", [fields], symbol, keys, index))
172
- : []),
173
- ];
174
- };
170
+ export const getRecordAxioms = (fields: string[], isExcept: boolean) => [
171
+ ...getComponentFunction("Rec", [fields], tla(`Record_${fields.join("_")}`), getFieldKeys(fields)),
172
+ ...(isExcept ? getRecordExcepts(fields) : []),
173
+ ];
175
174
 
176
175
  // The set of tuples or records whose components are in the given sets.
177
176
  export const getComponentSet = (
@@ -3,13 +3,16 @@
3
3
 
4
4
  import { TlaUnsupportedError } from "../../errors";
5
5
  import {
6
- TYPINGS,
6
+ getComponentSet,
7
7
  getEnumeration,
8
+ getFieldKeys,
8
9
  getIntegers,
9
- getTupleAxioms,
10
10
  getRecordAxioms,
11
- getComponentExcept,
12
- getComponentSet,
11
+ getRecordExcepts,
12
+ getTupleAxioms,
13
+ getTupleExcepts,
14
+ getTyping,
15
+ TYPED_OPERATORS,
13
16
  } from "./axioms";
14
17
  import {
15
18
  APPEND,
@@ -19,7 +22,6 @@ import {
19
22
  CAST_INT,
20
23
  CAT,
21
24
  declare,
22
- formatName,
23
25
  forall,
24
26
  FUN_APP,
25
27
  FUN_DOM,
@@ -77,7 +79,7 @@ export const getSymbolSpec = (name: string, state: CollectState): SymbolSpec =>
77
79
  deps,
78
80
  axioms,
79
81
  });
80
- const symbol = formatName(`TLA__${name}`);
82
+ const symbol = tla(name);
81
83
  const fixed = (arity: number, deps: string[], axioms: Axiom[], sort = "Idv") =>
82
84
  spec(declare(symbol, arity, sort), deps, axioms);
83
85
  const enumeration = /^SetEnum_(\d+)$/.exec(name);
@@ -154,26 +156,14 @@ export const getSymbolSpec = (name: string, state: CollectState): SymbolSpec =>
154
156
  return fixed(
155
157
  fields.length,
156
158
  ["Mem", record, "FunApp", ...fields.map((field) => `StrLit_${field}`)],
157
- getComponentSet(
158
- "RecSet",
159
- [fields],
160
- symbol,
161
- tla(record),
162
- fields.map((field) => tla(`StrLit_${field}`)),
163
- "r",
164
- ),
159
+ getComponentSet("RecSet", [fields], symbol, tla(record), getFieldKeys(fields), "r"),
165
160
  );
166
161
  }
167
162
  const anonymous = state.anonymous.get(name);
168
163
  if (anonymous !== undefined) return fixed(anonymous, [], []);
169
- const typing = TYPINGS[name];
170
- if (typing)
171
- return fixed(
172
- name === "IntUminus" ? 1 : 2,
173
- ["Cast_Int"],
174
- [typing()],
175
- name === "IntLteq" ? "Bool" : "Idv",
176
- );
164
+ const typed = TYPED_OPERATORS[name];
165
+ if (typed)
166
+ return fixed(typed[1], ["Cast_Int"], [getTyping(name)], name === "IntLteq" ? "Bool" : "Idv");
177
167
  switch (name) {
178
168
  // SMT-LIB has no exponentiation, so IntExp keeps only its typing.
179
169
  case "IntExp":
@@ -409,31 +399,12 @@ export const getSymbolSpec = (name: string, state: CollectState): SymbolSpec =>
409
399
  [],
410
400
  `(forall ((f Idv) (x Idv) (y Idv) (z Idv)) (! (=> (${MEM} z (${FUN_DOM} f)) (and (=> (= z x) (= (${FUN_APP} ${updated} z) y)) (=> (distinct z x) (= (${FUN_APP} ${updated} z) (${FUN_APP} f z))))) :pattern ((${FUN_APP} ${updated} z)) :pattern (${updated} (${FUN_APP} f z))))`,
411
401
  ),
412
- ...state.tuples.flatMap((count) =>
413
- getIntegers(count).map((_key, index) =>
414
- getComponentExcept(
415
- "TupExcept",
416
- [count],
417
- tla(`Tuple_${count}`),
418
- getIntegers(count),
419
- index,
420
- ),
421
- ),
422
- ),
423
- ...state.records.flatMap((recordFields) =>
424
- recordFields.map((_field, index) =>
425
- getComponentExcept(
426
- "RecExcept",
427
- [recordFields],
428
- tla(`Record_${recordFields.join("_")}`),
429
- recordFields.map((field) => tla(`StrLit_${field}`)),
430
- index,
431
- ),
432
- ),
433
- ),
402
+ ...state.tuples.flatMap(getTupleExcepts),
403
+ ...state.records.flatMap(getRecordExcepts),
434
404
  ],
435
405
  );
436
406
  }
407
+ // tlapm labels SeqSetElim1 and SeqSetElim2 SetSetElim1 and SetSetElim2.
437
408
  case "Seq":
438
409
  return fixed(
439
410
  1,
@@ -656,7 +627,7 @@ export const getSymbolSpec = (name: string, state: CollectState): SymbolSpec =>
656
627
  case "Tt_Idv":
657
628
  return fixed(0, [], []);
658
629
  case "TIntLteq":
659
- return spec(undefined, ["IntLteq"], [TYPINGS.IntLteq()]);
630
+ return spec(undefined, ["IntLteq"], [getTyping("IntLteq")]);
660
631
  default:
661
632
  // The rest are numerals, which SMT-LIB has natively.
662
633
  if (name.startsWith("TIntLit_")) return spec(undefined, [], []);
@@ -3,24 +3,134 @@
3
3
  // and each symbol the obligation uses brings the symbols and axioms encode/n_data.ml lists for it.
4
4
 
5
5
  import {
6
- adjoin,
6
+ applyBuiltin,
7
+ at,
8
+ mapChildren,
7
9
  type Expr,
8
10
  type Hyp,
9
- type Scope,
10
11
  type Sequent,
11
12
  } from "../../obligations/expression";
12
13
  import { compareStrings } from "../ocaml";
13
- import { collectSymbols } from "./axiomatize";
14
14
  import { createPrinter } from "./context";
15
+ import { getSymbolSpec, type CollectState, type SymbolSpec } from "./data";
15
16
  import type { Entry } from "./flatten";
16
- import { declare, MEM } from "./format";
17
- import { simplifyRecordEqualities, sortRecordFields } from "./simplify";
17
+ import { declare, getTlaName, MEM } from "./format";
18
18
  import { createEncoder, type Binding, type EncodingSession, type Env, type Mode } from "./rewrite";
19
- import { compareAxioms } from "./table";
19
+ import { compareAxioms, getAxiomKey, type Axiom } from "./table";
20
+
21
+ type RecordExpr = Extract<Expr, { kind: "Record" }>;
22
+
23
+ const isSameFieldSet = (left: RecordExpr, right: RecordExpr) =>
24
+ left.fields.length === right.fields.length &&
25
+ left.fields.every((field) => right.fields.some((other) => other.name === field.name)) &&
26
+ right.fields.every((field) => left.fields.some((other) => other.name === field.name));
27
+
28
+ // mk_conj: e1 /\ (e2 /\ ...).
29
+ const conjoinRight = (items: Expr[]): Expr =>
30
+ items.length === 1
31
+ ? items[0]
32
+ : applyBuiltin("Conj", [items[0], conjoinRight(items.slice(1))], items[0]);
33
+
34
+ const decompose = (left: Expr, right: Expr, from: Expr): Expr => {
35
+ if (left.kind !== "Record" || right.kind !== "Record" || !isSameFieldSet(left, right))
36
+ return applyBuiltin("Eq", [left, right], from);
37
+ return conjoinRight(
38
+ left.fields.map((field) =>
39
+ decompose(
40
+ field.value,
41
+ right.fields.find((other) => other.name === field.name)?.value ?? field.value,
42
+ from,
43
+ ),
44
+ ),
45
+ );
46
+ };
47
+
48
+ // N_rewrite.simpl_receq, before Type.Synthesize: an equality of two record constructors with the same fields is the conjunction of
49
+ // the equalities of their fields, paired by name.
50
+ const simplifyRecordEqualities = (expression: Expr): Expr => {
51
+ const inner = mapChildren(expression, simplifyRecordEqualities);
52
+ if (
53
+ inner.kind !== "Apply" ||
54
+ inner.operator.kind !== "Internal" ||
55
+ inner.operator.builtin !== "Eq" ||
56
+ inner.args.length !== 2 ||
57
+ inner.args[0].kind !== "Record" ||
58
+ inner.args[1].kind !== "Record"
59
+ )
60
+ return inner;
61
+ return at(decompose(inner.args[0], inner.args[1], inner), inner);
62
+ };
63
+
64
+ // N_rewrite.sort_recfields: a record's or a record set's fields in order. Like tlapm, it doesn't visit the
65
+ // field values, so a record inside a record keeps the order it's written in.
66
+ const sortRecordFields = (expression: Expr): Expr =>
67
+ expression.kind === "Record" || expression.kind === "Rect"
68
+ ? {
69
+ ...expression,
70
+ fields: expression.fields.toSorted((left, right) => compareStrings(left.name, right.name)),
71
+ }
72
+ : mapChildren(expression, sortRecordFields);
73
+
74
+ // N_axiomatize.collect: each symbol the obligation uses, in the order tlapm visits them, brings
75
+ // the symbols and axioms it depends on, smallest name first.
76
+ const collectSymbols = (entries: Entry[], encoder: Encoder) => {
77
+ const state: CollectState = {
78
+ recordFields: encoder.recordFields,
79
+ strings: [],
80
+ isFunConstr: false,
81
+ isFunSet: false,
82
+ isExcept: false,
83
+ tuples: [],
84
+ records: [],
85
+ anonymous: encoder.anonymous,
86
+ };
87
+ const symbols = new Map<string, SymbolSpec>();
88
+ const axioms = new Map<string, Axiom>();
89
+ const add = (name: string) => {
90
+ const work = new Set([name]);
91
+ while (work.size > 0) {
92
+ const next = [...work].toSorted(compareStrings)[0];
93
+ work.delete(next);
94
+ if (symbols.has(next)) continue;
95
+ const spec = getSymbolSpec(next, state);
96
+ symbols.set(next, spec);
97
+ spec.deps.forEach((dep) => work.add(dep));
98
+ spec.axioms.forEach((entry) => axioms.set(getAxiomKey(entry), entry));
99
+ }
100
+ };
101
+ // A flattened symbol stands for a builtin applied to its first-order arguments and then its
102
+ // higher-order ones, so its higher-order text is visited after its arguments.
103
+ const visit = (text: string) => {
104
+ const tokens = text.match(/[()]|[^\s()]+/g) ?? [];
105
+ const pending: { depth: number; text: string }[] = [];
106
+ tokens.reduce((depth, token, index) => {
107
+ if (token === "(") return depth + 1;
108
+ if (token === ")") {
109
+ if (pending.at(-1)?.depth === depth) visit(pending.pop()?.text ?? "");
110
+ return depth - 1;
111
+ }
112
+ const flat = encoder.flattened.get(token);
113
+ if (!flat) {
114
+ const builtin = getTlaName(token);
115
+ if (builtin !== undefined) add(builtin);
116
+ return depth;
117
+ }
118
+ if (flat.kind !== "") add(flat.kind);
119
+ if (tokens[index - 1] === "(") pending.push({ depth, text: flat.visit });
120
+ else visit(flat.visit);
121
+ return depth;
122
+ }, 0);
123
+ };
124
+ entries.forEach((entry) => {
125
+ if (typeof entry === "string") visit(entry);
126
+ else if ("omitted" in entry) visit(entry.omitted);
127
+ });
128
+ return { symbols, axioms };
129
+ };
20
130
 
21
131
  type Encoder = ReturnType<typeof createEncoder>;
22
132
 
23
- const HYPOTHESIS: Mode = { polarity: "Negative", at: undefined, depth: 0 };
133
+ const HYPOTHESIS: Mode = { isOmitted: false, polarity: "Negative", at: undefined, depth: 0 };
24
134
 
25
135
  // Prep.expand_defs substitutes visible definitions and pragmas, so they declare nothing.
26
136
  const isExpanded = (hyp: Extract<Hyp, { kind: "Defn" }>) =>
@@ -32,14 +142,17 @@ const isSecondOrder = (expression: Expr) =>
32
142
  expression.kind === "Sequent" &&
33
143
  expression.sequent.context.some((hyp) => hyp.kind === "Fresh" && hyp.shape > 0);
34
144
 
145
+ interface EncodedContext {
146
+ env: Env | undefined;
147
+ entries: Entry[];
148
+ }
149
+
35
150
  // Declares each hypothesis's names and asserts its facts, in order, as Smtlib.pp_print_obligation.
36
- // Visible definitions and TLAPS's pragmas are expanded, so they declare nothing.
37
151
  const encodeContext = (context: Hyp[], encoder: Encoder) =>
38
- context.reduce<{ env: Env | undefined; scope: Scope | undefined; entries: Entry[] }>(
152
+ context.reduce<EncodedContext>(
39
153
  (state, hyp) => {
40
154
  const next = (binding: Binding, entries: Entry[] = []) => ({
41
155
  env: encoder.push(state.env, binding),
42
- scope: adjoin(state.scope, hyp),
43
156
  entries: [...state.entries, ...entries],
44
157
  });
45
158
  switch (hyp.kind) {
@@ -50,10 +163,9 @@ const encodeContext = (context: Hyp[], encoder: Encoder) =>
50
163
  ? { kind: "constant", symbol }
51
164
  : { kind: "operator", symbol, arity: hyp.shape };
52
165
  const declaration = declare(symbol, hyp.shape);
53
- const domain = hyp.domain;
54
- if (!domain || hyp.domainVisibility === "Hidden") return next(binding, [declaration]);
166
+ if (!hyp.domain || hyp.domainVisibility === "Hidden") return next(binding, [declaration]);
55
167
  // Rewrite.elim_bounds: NEW x \in S is NEW x and the fact x \in S.
56
- const fact = `(assert (${MEM} ${symbol} ${encoder.encodeIdv(domain, state.env, HYPOTHESIS)}))`;
168
+ const fact = `(assert (${MEM} ${symbol} ${encoder.encodeIdv(hyp.domain, state.env, HYPOTHESIS)}))`;
57
169
  return next(binding, [declaration, ...encoder.getEntries(fact)]);
58
170
  }
59
171
  // Rewrite.elim_flex: a variable is two constants, the second for its primed value.
@@ -95,21 +207,20 @@ const encodeContext = (context: Hyp[], encoder: Encoder) =>
95
207
  case "Fact": {
96
208
  const binding: Binding = { kind: "unsupported", reason: "a reference to a fact" };
97
209
  if (hyp.visibility === "Hidden") return next(binding);
98
- if (!isSecondOrder(hyp.expression)) {
99
- const fact = `(assert ${encoder.encodeBool(hyp.expression, state.env, HYPOTHESIS)})`;
100
- return next(binding, encoder.getEntries(fact));
101
- }
102
- const fact = `(assert ${encoder.encodeBool(hyp.expression, state.env, { ...HYPOTHESIS, isOmitted: true })})`;
210
+ const isOmitted = isSecondOrder(hyp.expression);
211
+ const entries = encoder.getEntries(
212
+ `(assert ${encoder.encodeBool(hyp.expression, state.env, { ...HYPOTHESIS, isOmitted })})`,
213
+ );
103
214
  return next(
104
215
  binding,
105
- encoder
106
- .getEntries(fact)
107
- .map((entry) => (typeof entry === "string" ? { omitted: entry } : entry)),
216
+ isOmitted
217
+ ? entries.map((entry) => (typeof entry === "string" ? { omitted: entry } : entry))
218
+ : entries,
108
219
  );
109
220
  }
110
221
  }
111
222
  },
112
- { env: undefined, scope: undefined, entries: [] },
223
+ { env: undefined, entries: [] },
113
224
  );
114
225
 
115
226
  // Smtlib.pp_print_obligation: the logic, the sort, the builtin symbols by name, their axioms,
@@ -129,12 +240,7 @@ export const encodeSmt = (prepared: Sequent, session: EncodingSession) => {
129
240
  );
130
241
  const entries = [...context.entries, ...goal];
131
242
  const printer = createPrinter(encoder.declared);
132
- const collected = collectSymbols(
133
- entries,
134
- encoder.flattened,
135
- encoder.anonymous,
136
- encoder.recordFields,
137
- );
243
+ const collected = collectSymbols(entries, encoder);
138
244
  const declarations = [...collected.symbols]
139
245
  .toSorted((left, right) => compareStrings(left[0], right[0]))
140
246
  .flatMap((symbol) => (symbol[1].declaration === undefined ? [] : [symbol[1].declaration]));
@@ -1,7 +1,18 @@
1
1
  // Standardize.set_extensionality_visitor: an equality of sets where it may need proving triggers
2
2
  // the set extensionality axiom, through TrigEq.
3
3
 
4
- import { CAP, CUP, FUN_SET, INT_RANGE, SEQ, SET_MINUS, SUBSET, TRIG_EQ, UNION } from "./format";
4
+ import {
5
+ CAP,
6
+ CUP,
7
+ FUN_SET,
8
+ getClosing,
9
+ INT_RANGE,
10
+ SEQ,
11
+ SET_MINUS,
12
+ SUBSET,
13
+ TRIG_EQ,
14
+ UNION,
15
+ } from "./format";
5
16
 
6
17
  export type Polarity = "Positive" | "Negative" | "Neither";
7
18
 
@@ -27,18 +38,9 @@ const isSetTerm = (text: string) => {
27
38
  export const resolveTriggers = (text: string, isTriggered: boolean): string => {
28
39
  const start = text.indexOf(`(${UNRESOLVED_TRIGGER} `);
29
40
  if (start === -1) return text;
30
- const getEnd = (from: number) => {
31
- const end = { depth: 0, index: from };
32
- for (; end.index < text.length; end.index++) {
33
- if (text[end.index] === "(") end.depth++;
34
- if (text[end.index] === ")") end.depth--;
35
- if (end.depth === 0) return end.index + 1;
36
- }
37
- return text.length;
38
- };
39
41
  const triggeredStart = start + UNRESOLVED_TRIGGER.length + 2;
40
- const triggeredEnd = getEnd(triggeredStart);
41
- const keptEnd = getEnd(triggeredEnd + 1);
42
+ const triggeredEnd = getClosing(text, triggeredStart) + 1;
43
+ const keptEnd = getClosing(text, triggeredEnd + 1) + 1;
42
44
  const chosen = isTriggered
43
45
  ? text.slice(triggeredStart, triggeredEnd)
44
46
  : text.slice(triggeredEnd + 1, keptEnd);
@@ -1,7 +1,7 @@
1
1
  // encode/n_flatten.ml: each application of a second-order construct becomes a fresh first-order
2
2
  // symbol, declared with its axioms before the fact that uses it.
3
3
 
4
- import { declare, formatName } from "./format";
4
+ import { declare, formatName, getClosing } from "./format";
5
5
  import type { Axiom } from "./table";
6
6
 
7
7
  // A symbol that Flatten introduces, with the text tlapm's collect pass visits for its
@@ -14,7 +14,7 @@ export interface Flattened {
14
14
  }
15
15
 
16
16
  // A fact that tlapm encodes, so its symbols bring their axioms, but leaves out of the text.
17
- export interface OmittedFact {
17
+ interface OmittedFact {
18
18
  omitted: string;
19
19
  }
20
20
 
@@ -29,20 +29,6 @@ export const getDepth = (variable: string) => Number(variable.slice(variable.las
29
29
  // (?unprimable term). Flatten.compare_expr tells it apart, and the printed text drops it.
30
30
  export const UNPRIMABLE = "?unprimable";
31
31
 
32
- const getClosing = (text: string, from: number) => {
33
- const state = { depth: 0 };
34
- for (const index of Array.from(
35
- { length: text.length - from },
36
- (_value, offset) => from + offset,
37
- )) {
38
- if (text[index] === "(") state.depth++;
39
- if (text[index] === ")") state.depth--;
40
- if (state.depth === 0) return index;
41
- }
42
- return text.length;
43
- };
44
-
45
- // The text with each Unprimable mark dropped.
46
32
  export const removeUnprimable = (text: string): string => {
47
33
  const start = text.indexOf(`(${UNPRIMABLE} `);
48
34
  if (start === -1) return text;
@@ -68,7 +54,7 @@ const getFlatKey = (text: string, depth: number) =>
68
54
  // Smtlib leaves out, which Flatten doesn't enter.
69
55
  interface Site {
70
56
  depth: number;
71
- isOmitted?: boolean;
57
+ isOmitted: boolean;
72
58
  }
73
59
 
74
60
  // The state of Flatten.main over one obligation: its blueprint count, which init_bp_count resets
@@ -120,7 +106,6 @@ export const createFlattener = () => {
120
106
  return symbol;
121
107
  };
122
108
 
123
- // The symbols introduced since the last call, in order.
124
109
  const takeIntroduced = () => introduced.splice(0);
125
110
 
126
111
  return { flattened, flatten, takeIntroduced };
@@ -110,8 +110,8 @@ export const BUILTIN_SYMBOLS: Partial<Record<Builtin, string>> = {
110
110
  export const getNames = (prefix: string, count: number) =>
111
111
  Array.from({ length: count }, (_value, index) => `${prefix}${index + 1}`);
112
112
 
113
- const getSortedBinders = (variables: [string, string][]) =>
114
- variables.map((variable) => `(${variable[0]} ${variable[1]})`).join(" ");
113
+ export const getBinders = (variables: string[], sort = "Idv") =>
114
+ variables.map((variable) => `(${variable} ${sort})`).join(" ");
115
115
 
116
116
  export const forall = (
117
117
  variables: string[],
@@ -121,7 +121,7 @@ export const forall = (
121
121
  ) =>
122
122
  variables.length === 0
123
123
  ? body
124
- : `(forall (${getSortedBinders(variables.map((variable) => [variable, sort]))}) ${
124
+ : `(forall (${getBinders(variables, sort)}) ${
125
125
  patterns.length === 0
126
126
  ? body
127
127
  : `(! ${body} ${patterns.map((pattern) => `:pattern (${pattern.join(" ")})`).join(" ")})`
@@ -139,5 +139,16 @@ export const call = (symbol: string, args: string[]) =>
139
139
  export const declare = (symbol: string, arity: number, sort = "Idv", argSort = "Idv") =>
140
140
  `(declare-fun ${symbol} (${Array.from({ length: arity }, () => argSort).join(" ")}) ${sort})`;
141
141
 
142
+ // The index of the parenthesis that closes the one at from.
143
+ export const getClosing = (text: string, from: number) => {
144
+ const state = { depth: 0, index: from };
145
+ for (; state.index < text.length; state.index++) {
146
+ if (text[state.index] === "(") state.depth++;
147
+ if (text[state.index] === ")") state.depth--;
148
+ if (state.depth === 0) return state.index;
149
+ }
150
+ return text.length;
151
+ };
152
+
142
153
  export const replaceToken = (text: string, token: string, replacement: string) =>
143
154
  text.replace(/[^\s()]+/g, (found) => (found === token ? replacement : found));