tla-ts 0.0.4-dev.4819fb7 → 0.0.4-dev.55f2117

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 (360) hide show
  1. package/README.md +37 -126
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +33 -1
  8. package/dist/index.d.ts +33 -1
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +996 -0
  17. package/dist/prove.js +996 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +38 -44
  23. package/dist/transfer.js +38 -44
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/check.ts +8 -7
  29. package/src/{cli-options.ts → cli/options.ts} +1 -1
  30. package/src/{run-cli.ts → cli/run.ts} +302 -100
  31. package/src/cli.ts +1 -1
  32. package/src/codegen.ts +26 -7
  33. package/src/config.ts +2 -2
  34. package/src/environment.ts +9 -9
  35. package/src/errors.ts +89 -30
  36. package/src/evaluate.ts +58 -23
  37. package/src/index.ts +10 -0
  38. package/src/levels.ts +1 -1
  39. package/src/live-check.ts +1 -1
  40. package/src/liveness.ts +1 -1
  41. package/src/{obligation-action.ts → obligations/action.ts} +247 -69
  42. package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
  43. package/src/obligations/ctx.ts +64 -0
  44. package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
  45. package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
  46. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  47. package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
  48. package/src/{obligations.ts → obligations/index.ts} +32 -16
  49. package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
  50. package/src/{obligation-module.ts → obligations/module.ts} +113 -121
  51. package/src/obligations/pickle.ts +98 -0
  52. package/src/obligations/pragma.ts +189 -0
  53. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  54. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  55. package/src/{obligation-source.ts → obligations/source.ts} +154 -99
  56. package/src/obligations/temporal.ts +321 -0
  57. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  58. package/src/parallel-worker.ts +4 -20
  59. package/src/parallel.ts +13 -46
  60. package/src/parser.ts +1 -1
  61. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -2
  62. package/src/{pcal-parse.ts → pcal/parse.ts} +3 -3
  63. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +2 -2
  64. package/src/{pcal-translate.ts → pcal/translate.ts} +2 -2
  65. package/src/{pcal-validate.ts → pcal/validate.ts} +6 -6
  66. package/src/prove/decide-pool.ts +95 -0
  67. package/src/prove/deciders.ts +33 -0
  68. package/src/prove/first-order.ts +78 -0
  69. package/src/prove/isabelle/LICENSE +36 -0
  70. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  71. package/src/prove/isabelle/decide.ts +47 -0
  72. package/src/prove/isabelle/encode.ts +446 -0
  73. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  74. package/src/prove/isabelle/isar/method.ts +367 -0
  75. package/src/prove/isabelle/isar/proof.ts +28 -0
  76. package/src/prove/isabelle/isar/statement.ts +57 -0
  77. package/src/prove/isabelle/isar/theory.ts +192 -0
  78. package/src/prove/isabelle/isar/type-check.ts +278 -0
  79. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  80. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  81. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  82. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  83. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  84. package/src/prove/isabelle/provers/blast/term.ts +546 -0
  85. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  86. package/src/prove/isabelle/provers/classical.ts +389 -0
  87. package/src/prove/isabelle/provers/hypsubst.ts +433 -0
  88. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  89. package/src/prove/isabelle/pure/consts.ts +32 -0
  90. package/src/prove/isabelle/pure/conv.ts +79 -0
  91. package/src/prove/isabelle/pure/drule.ts +264 -0
  92. package/src/prove/isabelle/pure/envir.ts +331 -0
  93. package/src/prove/isabelle/pure/goal.ts +53 -0
  94. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  95. package/src/prove/isabelle/pure/list.ts +12 -0
  96. package/src/prove/isabelle/pure/logic.ts +330 -0
  97. package/src/prove/isabelle/pure/name.ts +98 -0
  98. package/src/prove/isabelle/pure/net.ts +215 -0
  99. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  100. package/src/prove/isabelle/pure/pattern.ts +631 -0
  101. package/src/prove/isabelle/pure/raw-simplifier.ts +338 -0
  102. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  103. package/src/prove/isabelle/pure/search.ts +68 -0
  104. package/src/prove/isabelle/pure/seq.ts +133 -0
  105. package/src/prove/isabelle/pure/simplifier.ts +106 -0
  106. package/src/prove/isabelle/pure/table.ts +201 -0
  107. package/src/prove/isabelle/pure/tactic.ts +168 -0
  108. package/src/prove/isabelle/pure/tactical.ts +264 -0
  109. package/src/prove/isabelle/pure/term-ord.ts +105 -0
  110. package/src/prove/isabelle/pure/term.ts +688 -0
  111. package/src/prove/isabelle/pure/thm.ts +783 -0
  112. package/src/prove/isabelle/pure/type.ts +121 -0
  113. package/src/prove/isabelle/pure/unify.ts +753 -0
  114. package/src/prove/isabelle/pure/variable.ts +25 -0
  115. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  116. package/src/prove/isabelle/tla/context.ts +74 -0
  117. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  118. package/src/prove/isabelle/tla/logic.ts +215 -0
  119. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  120. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  121. package/src/prove/ocaml.ts +22 -0
  122. package/src/prove/prep/action.ts +508 -0
  123. package/src/prove/prep/defs.ts +33 -0
  124. package/src/prove/prep/elab.ts +156 -0
  125. package/src/prove/prep/enabled-axioms.ts +189 -0
  126. package/src/prove/prep/enabled.ts +43 -0
  127. package/src/prove/prep/fingerprint.ts +388 -0
  128. package/src/prove/prep/flatten.ts +70 -0
  129. package/src/prove/prep/level-comparison.ts +529 -0
  130. package/src/prove/prep/md5.ts +67 -0
  131. package/src/prove/prep/pragma.ts +221 -0
  132. package/src/prove/prep/trivial.ts +22 -0
  133. package/src/prove/prove-worker.ts +22 -0
  134. package/src/prove/prove.ts +498 -0
  135. package/src/prove/ptl/decide.ts +68 -0
  136. package/src/prove/ptl/encode.ts +255 -0
  137. package/src/prove/ptl/sat.ts +151 -0
  138. package/src/prove/ptl/tableau.ts +276 -0
  139. package/src/prove/smt/axiomatize.ts +69 -0
  140. package/src/prove/smt/axioms.ts +209 -0
  141. package/src/prove/smt/context.ts +108 -0
  142. package/src/prove/smt/data.ts +636 -0
  143. package/src/prove/smt/encode.ts +164 -0
  144. package/src/prove/smt/extensionality.ts +65 -0
  145. package/src/prove/smt/flatten.ts +112 -0
  146. package/src/prove/smt/format.ts +154 -0
  147. package/src/prove/smt/instances.ts +181 -0
  148. package/src/prove/smt/rewrite.ts +772 -0
  149. package/src/prove/smt/simplify.ts +57 -0
  150. package/src/prove/smt/solver/act-cache.ts +265 -0
  151. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  152. package/src/prove/smt/solver/array.ts +22 -0
  153. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  154. package/src/prove/smt/solver/ast-lt.ts +157 -0
  155. package/src/prove/smt/solver/ast-util.ts +91 -0
  156. package/src/prove/smt/solver/ast.ts +1315 -0
  157. package/src/prove/smt/solver/auf-solver.ts +572 -0
  158. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  159. package/src/prove/smt/solver/cg-table.ts +175 -0
  160. package/src/prove/smt/solver/clause.ts +276 -0
  161. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  162. package/src/prove/smt/solver/context.ts +1292 -0
  163. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  164. package/src/prove/smt/solver/der.ts +224 -0
  165. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  166. package/src/prove/smt/solver/e-matching.ts +659 -0
  167. package/src/prove/smt/solver/enode.ts +259 -0
  168. package/src/prove/smt/solver/expr-ref.ts +21 -0
  169. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  170. package/src/prove/smt/solver/fingerprints.ts +92 -0
  171. package/src/prove/smt/solver/flat-literals.ts +51 -0
  172. package/src/prove/smt/solver/goal.ts +138 -0
  173. package/src/prove/smt/solver/hash.ts +173 -0
  174. package/src/prove/smt/solver/hashtable.ts +166 -0
  175. package/src/prove/smt/solver/internalizer.ts +1381 -0
  176. package/src/prove/smt/solver/lbool.ts +5 -0
  177. package/src/prove/smt/solver/literal.ts +24 -0
  178. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  179. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  180. package/src/prove/smt/solver/lp/containers.ts +296 -0
  181. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  182. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  183. package/src/prove/smt/solver/lp/dep-intervals.ts +642 -0
  184. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  185. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  186. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  187. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  188. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  189. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  190. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  191. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  192. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  193. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  194. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  195. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  196. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  197. package/src/prove/smt/solver/lp/nex.ts +120 -0
  198. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  199. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  200. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  201. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  202. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  203. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  204. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  205. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  206. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  207. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  208. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  209. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  210. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  211. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  212. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  213. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  214. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  215. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  216. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  217. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  218. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  219. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  220. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  221. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  222. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  223. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  224. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  225. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  226. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  227. package/src/prove/smt/solver/model-checker.ts +347 -0
  228. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  229. package/src/prove/smt/solver/model-finder.ts +155 -0
  230. package/src/prove/smt/solver/model-generator.ts +97 -0
  231. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  232. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  233. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  234. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  235. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  236. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  237. package/src/prove/smt/solver/nlsat/levelwise.ts +737 -0
  238. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  239. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  240. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  241. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  242. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  243. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  244. package/src/prove/smt/solver/nnf.ts +469 -0
  245. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  246. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  247. package/src/prove/smt/solver/propagate-values.ts +83 -0
  248. package/src/prove/smt/solver/proto-model.ts +551 -0
  249. package/src/prove/smt/solver/pull-quant.ts +139 -0
  250. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  251. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  252. package/src/prove/smt/solver/qe-lite.ts +381 -0
  253. package/src/prove/smt/solver/qi-queue.ts +362 -0
  254. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  255. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  256. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  257. package/src/prove/smt/solver/random-gen.ts +10 -0
  258. package/src/prove/smt/solver/rational.ts +165 -0
  259. package/src/prove/smt/solver/ref-vector.ts +62 -0
  260. package/src/prove/smt/solver/relevancy.ts +247 -0
  261. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  262. package/src/prove/smt/solver/rewriter.ts +843 -0
  263. package/src/prove/smt/solver/rlimit.ts +79 -0
  264. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  265. package/src/prove/smt/solver/solver.ts +71 -0
  266. package/src/prove/smt/solver/sort.ts +35 -0
  267. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  268. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  269. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  270. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  271. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  272. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  273. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  274. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  275. package/src/prove/smt/solver/theory-lra.ts +56 -0
  276. package/src/prove/smt/solver/var-subst.ts +258 -0
  277. package/src/prove/smt/solver/z3-license.txt +10 -0
  278. package/src/prove/smt/table.ts +170 -0
  279. package/src/prove/tlapm/cache.ts +236 -0
  280. package/src/prove/tlapm/ocaml-marshal.ts +166 -0
  281. package/src/prove/tlapm/tlapm.ts +96 -0
  282. package/src/prove/tlaps-module.ts +510 -0
  283. package/src/prove/verdict.ts +18 -0
  284. package/src/prove/zenon/LICENSE +32 -0
  285. package/src/prove/zenon/check/check.ts +105 -0
  286. package/src/prove/zenon/check/definitions.ts +144 -0
  287. package/src/prove/zenon/check/equality.ts +182 -0
  288. package/src/prove/zenon/check/functions.ts +62 -0
  289. package/src/prove/zenon/check/keys.ts +125 -0
  290. package/src/prove/zenon/check/propositional.ts +104 -0
  291. package/src/prove/zenon/check/records.ts +188 -0
  292. package/src/prove/zenon/check/relations.ts +121 -0
  293. package/src/prove/zenon/check/rewrites.ts +224 -0
  294. package/src/prove/zenon/check/sets.ts +302 -0
  295. package/src/prove/zenon/check/terms.ts +127 -0
  296. package/src/prove/zenon/check/tla.ts +126 -0
  297. package/src/prove/zenon/decide.ts +113 -0
  298. package/src/prove/zenon/encode.ts +379 -0
  299. package/src/prove/zenon/eqrel.ts +300 -0
  300. package/src/prove/zenon/equality-rules.ts +435 -0
  301. package/src/prove/zenon/expr.ts +551 -0
  302. package/src/prove/zenon/index-table.ts +350 -0
  303. package/src/prove/zenon/isar-case.ts +513 -0
  304. package/src/prove/zenon/isar.ts +1249 -0
  305. package/src/prove/zenon/limits.ts +15 -0
  306. package/src/prove/zenon/llproof.ts +173 -0
  307. package/src/prove/zenon/mltoll.ts +1566 -0
  308. package/src/prove/zenon/node.ts +297 -0
  309. package/src/prove/zenon/ocaml.ts +169 -0
  310. package/src/prove/zenon/parse.ts +247 -0
  311. package/src/prove/zenon/phrase.ts +191 -0
  312. package/src/prove/zenon/proof.ts +198 -0
  313. package/src/prove/zenon/propositional-rules.ts +387 -0
  314. package/src/prove/zenon/rules.ts +94 -0
  315. package/src/prove/zenon/search.ts +288 -0
  316. package/src/prove/zenon/tla/functions.ts +151 -0
  317. package/src/prove/zenon/tla/llproof.ts +480 -0
  318. package/src/prove/zenon/tla/records.ts +225 -0
  319. package/src/prove/zenon/tla/rewrites.ts +447 -0
  320. package/src/prove/zenon/tla/sets.ts +304 -0
  321. package/src/prove/zenon/tla/terms.ts +162 -0
  322. package/src/prove/zenon/tla/tla.ts +506 -0
  323. package/src/randomization.ts +1 -1
  324. package/src/resolve.ts +1 -1
  325. package/src/runtime.ts +2 -2
  326. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  327. package/src/{sany-generator.ts → sany/generator.ts} +14 -14
  328. package/src/{sany-levels.ts → sany/levels.ts} +2 -2
  329. package/src/{sany-lexer.ts → sany/lexer.ts} +1 -1
  330. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  331. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  332. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  333. package/src/{sany-report.ts → sany/report.ts} +15 -15
  334. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -3
  335. package/src/{sany-source.ts → sany/source.ts} +6 -6
  336. package/src/{sany-xml.ts → sany/xml.ts} +5 -5
  337. package/src/spec-description.ts +1 -1
  338. package/src/{standard-levels.ts → standard/levels.ts} +1 -1
  339. package/src/{standard-modules.ts → standard/modules.ts} +17 -14
  340. package/src/{standard-ranges.ts → standard/ranges.ts} +1 -1
  341. package/src/state-graph.ts +1 -1
  342. package/src/successors.ts +25 -6
  343. package/src/symmetry.ts +1 -1
  344. package/src/{tlc-messages.ts → tlc/messages.ts} +2 -2
  345. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  346. package/src/{tlc-random.ts → tlc/random.ts} +58 -35
  347. package/src/{tlc-replay.ts → tlc/replay.ts} +5 -5
  348. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  349. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +14 -8
  350. package/src/{tlc-version.ts → tlc/version.ts} +8 -7
  351. package/src/values.ts +81 -36
  352. package/src/worker.ts +65 -0
  353. package/dist/parallel.cjs +0 -12
  354. package/dist/parallel.js +0 -12
  355. package/dist/run-cli.cjs +0 -55
  356. package/dist/run-cli.js +0 -55
  357. package/src/value-sources.ts +0 -29
  358. /package/src/{sany-nodes.ts → sany/nodes.ts} +0 -0
  359. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  360. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
@@ -0,0 +1,506 @@
1
+ // Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
2
+ //
3
+ // The TLA+ extension: rules for set theory, functions, records, tuples, CHOOSE, IF and CASE, and
4
+ // rewriting a subterm with an equality on the branch.
5
+
6
+ import {
7
+ FALSE,
8
+ isApp,
9
+ TRUE,
10
+ type Expr,
11
+ type Expressions,
12
+ type NegatedRelationExpr,
13
+ type RelationExpr,
14
+ } from "../expr";
15
+ import type { Node, Priority } from "../node";
16
+ import type { Phrase } from "../parse";
17
+ import { makeRule, type Rule } from "../proof";
18
+ import { getFunctionNodes, getFunctionSetNodes } from "./functions";
19
+ import { getRecordNodes, getTupleNodes } from "./records";
20
+ import { getRewriteNodes } from "./rewrites";
21
+ import {
22
+ getMembershipNodes,
23
+ getMetaMembershipNodes,
24
+ getSetEqualityNodes,
25
+ getSubsetNodes,
26
+ } from "./sets";
27
+ import {
28
+ equal,
29
+ FUNCTION_CONSTRUCTORS,
30
+ getLiteral,
31
+ isNotEquiv,
32
+ isVariable,
33
+ makeExtensionNode,
34
+ makeInstanceNode,
35
+ member,
36
+ SET_CONSTRUCTORS,
37
+ type Item,
38
+ type Literal,
39
+ type TlaContext,
40
+ } from "./terms";
41
+
42
+ const OTHER_SYMBOLS = [
43
+ "TLA.in",
44
+ "TLA.isAFcn",
45
+ "TLA.cond",
46
+ "TLA.CASE",
47
+ "TLA.tuple",
48
+ "TLA.record",
49
+ "TLA.fapply",
50
+ "TLA.box",
51
+ ];
52
+
53
+ // The symbols that hypotheses can't define, as Zenon's predef with the tla extension.
54
+ export const PREDEFINED_SYMBOLS = [
55
+ "=",
56
+ ...SET_CONSTRUCTORS,
57
+ ...FUNCTION_CONSTRUCTORS,
58
+ ...OTHER_SYMBOLS,
59
+ ];
60
+
61
+ const definition = (
62
+ exprs: Expressions,
63
+ name: string,
64
+ symbol: string,
65
+ params: string[],
66
+ body: Expr,
67
+ ): Phrase => ({
68
+ kind: "def",
69
+ definition: {
70
+ kind: "real",
71
+ name,
72
+ symbol,
73
+ params: params.map((param) => exprs.evar(param)),
74
+ body,
75
+ },
76
+ });
77
+
78
+ // Zenon's built_in_defs. Expressions belong to one run of the prover, so each run builds them.
79
+ export const getBuiltInDefinitions = (exprs: Expressions): Phrase[] => {
80
+ const bound = exprs.evar("x");
81
+ const isInSet = exprs.eapp("TLA.in", [bound, exprs.evar("S")]);
82
+ const holds = exprs.eapp("P", [bound]);
83
+ return [
84
+ definition(
85
+ exprs,
86
+ "subset_def",
87
+ "TLA.subseteq",
88
+ ["A", "B"],
89
+ exprs.eapp("TLA.bAll", [
90
+ exprs.evar("A"),
91
+ exprs.elam(bound, "", exprs.eapp("TLA.in", [bound, exprs.evar("B")])),
92
+ ]),
93
+ ),
94
+ definition(
95
+ exprs,
96
+ "bAll_def",
97
+ "TLA.bAll",
98
+ ["S", "P"],
99
+ exprs.eall(bound, "", exprs.eimply(isInSet, holds)),
100
+ ),
101
+ definition(
102
+ exprs,
103
+ "bEx_def",
104
+ "TLA.bEx",
105
+ ["S", "P"],
106
+ exprs.eex(bound, "", exprs.eand(isInSet, holds)),
107
+ ),
108
+ definition(
109
+ exprs,
110
+ "bChoose_def",
111
+ "TLA.bChoice",
112
+ ["S", "P"],
113
+ exprs.etau(bound, "", exprs.eand(isInSet, holds)),
114
+ ),
115
+ definition(
116
+ exprs,
117
+ "prod_def",
118
+ "TLA.prod",
119
+ ["A", "B"],
120
+ exprs.eapp("TLA.Product", [exprs.eapp("TLA.tuple", [exprs.evar("A"), exprs.evar("B")])]),
121
+ ),
122
+ ];
123
+ };
124
+
125
+ // The elements of a set given by enumeration, and whether it may hold more.
126
+ const getSetValues = (set: Expr): [Expr[], boolean] => {
127
+ if (isVariable(set, "TLA.emptyset")) return [[], false];
128
+ if (isApp(set, "TLA.upair", 2)) return [set.args, false];
129
+ if (isApp(set, "TLA.set")) return [set.args, false];
130
+ if (isApp(set, "TLA.addElt", 2)) {
131
+ const rest = getSetValues(set.args[1]);
132
+ return [[set.args[0], ...rest[0]], rest[1]];
133
+ }
134
+ if (isApp(set, "TLA.union", 2)) {
135
+ const left = getSetValues(set.args[0]);
136
+ const right = getSetValues(set.args[1]);
137
+ return [[...left[0], ...right[0]], left[1] || right[1]];
138
+ }
139
+ return [[], true];
140
+ };
141
+
142
+ const getBooleanNodes = (literal: Literal): Item[] | undefined => {
143
+ const exprs = literal.context.exprs;
144
+ const formula = literal.formula;
145
+ const isNegated = literal.isNegated;
146
+ const atom = literal.atom;
147
+ const relation = literal.relation;
148
+ const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
149
+ makeExtensionNode(literal, priority, rule, branches);
150
+ const instance = (priority: Priority, quantified: Expr, term: Expr) =>
151
+ makeInstanceNode(literal, priority, quantified, term);
152
+ if (atom.kind === "meta") return instance("arity", atom.args[0], isNegated ? TRUE : FALSE);
153
+ if (relation?.symbol !== "=") return undefined;
154
+ const left = relation.args[0];
155
+ const right = relation.args[1];
156
+ if (right.kind === "true")
157
+ return isNegated
158
+ ? node("prop", makeRule("noteq_x_true", [formula, exprs.enot(left), left]), [
159
+ [exprs.enot(left)],
160
+ ])
161
+ : node("prop", makeRule("eq_x_true", [formula, left, left]), [[left]]);
162
+ if (left.kind === "true")
163
+ return isNegated
164
+ ? node("prop", makeRule("noteq_true_x", [formula, exprs.enot(right), right]), [
165
+ [exprs.enot(right)],
166
+ ])
167
+ : node("prop", makeRule("eq_true_x", [formula, right, right]), [[right]]);
168
+ if (!isNegated && right.kind === "false")
169
+ return node("prop", makeRule("eq_x_false", [formula, exprs.enot(left), left]), [
170
+ [exprs.enot(left)],
171
+ ]);
172
+ if (!isNegated && left.kind === "false")
173
+ return node("prop", makeRule("eq_false_x", [formula, exprs.enot(right), right]), [
174
+ [exprs.enot(right)],
175
+ ]);
176
+ return undefined;
177
+ };
178
+
179
+ const getChoiceNodes = (literal: Literal): Item[] | undefined => {
180
+ const exprs = literal.context.exprs;
181
+ const formula = literal.formula;
182
+ const goalness = literal.goalness;
183
+ const isNegated = literal.isNegated;
184
+ const relation = literal.relation;
185
+ const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
186
+ makeExtensionNode(literal, priority, rule, branches);
187
+ if (relation === undefined) return undefined;
188
+ const left = relation.args[0];
189
+ const right = relation.args[1];
190
+ const isEquality = relation.symbol === "=";
191
+ if (
192
+ isNegated &&
193
+ isEquality &&
194
+ left.kind === "tau" &&
195
+ right.kind === "tau" &&
196
+ !isNotEquiv(left.args[1]) &&
197
+ !isNotEquiv(right.args[1])
198
+ ) {
199
+ const bound = exprs.newVar();
200
+ const leftBody = exprs.substitute([[left.args[0], bound]], left.args[1]);
201
+ const rightBody = exprs.substitute([[right.args[0], bound]], right.args[1]);
202
+ const differ = exprs.eex(bound, left.symbol, exprs.eapp("$notequiv", [leftBody, rightBody]));
203
+ return node(
204
+ { instance: differ },
205
+ makeRule("choose_diff_choose", [
206
+ formula,
207
+ differ,
208
+ exprs.elam(left.args[0], left.symbol, left.args[1]),
209
+ exprs.elam(right.args[0], right.symbol, right.args[1]),
210
+ ]),
211
+ [[differ]],
212
+ );
213
+ }
214
+ if (!isNegated && relation.symbol === "$notequiv")
215
+ return node("arity", makeRule("notequivdef", []), [[exprs.enot(exprs.eequiv(left, right))]]);
216
+ const choice = right.kind === "tau" ? right : left.kind === "tau" ? left : undefined;
217
+ if (isNegated && isEquality && choice !== undefined) {
218
+ const term = right.kind === "tau" ? left : right;
219
+ const exists = exprs.eex(choice.args[0], choice.symbol, choice.args[1]);
220
+ const notExists = exprs.enot(exists);
221
+ const notHolds = exprs.enot(exprs.substitute([[choice.args[0], term]], choice.args[1]));
222
+ return [
223
+ {
224
+ conclusions: [],
225
+ rule: makeRule("notequalchoose", [
226
+ exists,
227
+ notExists,
228
+ notHolds,
229
+ exprs.elam(choice.args[0], choice.symbol, choice.args[1]),
230
+ term,
231
+ ]),
232
+ priority: { instance: notExists },
233
+ goalness,
234
+ branches: [[exists], [notExists, notHolds]],
235
+ },
236
+ ];
237
+ }
238
+ return undefined;
239
+ };
240
+
241
+ // The bounded quantifier over an enumerated set in \A x : x \in S => P or ~\E x : x \in S /\ P.
242
+ const getEnumeratedQuantifier = (formula: Expr) => {
243
+ const isEnumerated = (set: Expr) =>
244
+ isVariable(set, "TLA.emptyset") ||
245
+ (set.kind === "app" &&
246
+ ["TLA.addElt", "TLA.upair", "TLA.set", "TLA.union"].includes(set.symbol));
247
+ if (formula.kind === "all") {
248
+ const body = formula.args[1];
249
+ if (
250
+ body.kind === "imply" &&
251
+ isApp(body.args[0], "TLA.in", 2) &&
252
+ isEnumerated(body.args[0].args[1])
253
+ )
254
+ return { quantified: formula, set: body.args[0].args[1] };
255
+ }
256
+ if (formula.kind === "not" && formula.args[0].kind === "ex") {
257
+ const body = formula.args[0].args[1];
258
+ if (
259
+ body.kind === "and" &&
260
+ isApp(body.args[0], "TLA.in", 2) &&
261
+ isEnumerated(body.args[0].args[1])
262
+ )
263
+ return { quantified: formula.args[0], set: body.args[0].args[1] };
264
+ }
265
+ return undefined;
266
+ };
267
+
268
+ const getEnumeratedNodes = (literal: Literal): Item[] | undefined => {
269
+ const formula = literal.formula;
270
+ const instance = (priority: Priority, quantified: Expr, term: Expr) =>
271
+ makeInstanceNode(literal, priority, quantified, term);
272
+ const enumerated = getEnumeratedQuantifier(formula);
273
+ if (enumerated !== undefined) {
274
+ const values = getSetValues(enumerated.set);
275
+ const nodes: Item[] = values[0].flatMap((value) =>
276
+ instance("arity", enumerated.quantified, value),
277
+ );
278
+ return values[1] ? nodes : [...nodes, "stop"];
279
+ }
280
+ return undefined;
281
+ };
282
+
283
+ const getNaturalNodes = (literal: Literal): Item[] | undefined => {
284
+ const exprs = literal.context.exprs;
285
+ const formula = literal.formula;
286
+ const isNegated = literal.isNegated;
287
+ const relation = literal.relation;
288
+ const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
289
+ makeExtensionNode(literal, priority, rule, branches);
290
+ const instance = (priority: Priority, quantified: Expr, term: Expr) =>
291
+ makeInstanceNode(literal, priority, quantified, term);
292
+ if (isNegated && relation?.symbol === "TLA.in" && isVariable(relation.args[1], "arith.N")) {
293
+ const left = relation.args[0];
294
+ if (isVariable(left, "0")) return node("prop", makeRule("in_nat_0", [formula]), []);
295
+ if (isApp(left, "TLA.fapply", 2) && isVariable(left.args[0], "TLA.Succ")) {
296
+ const previous = exprs.enot(member(exprs, left.args[1], exprs.evar("arith.N")));
297
+ return node("prop", makeRule("in_nat_succ", [formula, previous, left.args[1]]), [[previous]]);
298
+ }
299
+ if (left.kind === "meta")
300
+ return instance({ instance: left.args[0] }, left.args[0], exprs.evar("0"));
301
+ }
302
+ return undefined;
303
+ };
304
+
305
+ const getPropNodes = (context: TlaContext, formula: Expr, goalness: number): Item[] => {
306
+ const literal = getLiteral(context, formula, goalness);
307
+ return (
308
+ getBooleanNodes(literal) ??
309
+ getMembershipNodes(literal) ??
310
+ getFunctionSetNodes(literal) ??
311
+ getSetEqualityNodes(literal) ??
312
+ getFunctionNodes(literal) ??
313
+ getChoiceNodes(literal) ??
314
+ getEnumeratedNodes(literal) ??
315
+ getNaturalNodes(literal) ??
316
+ getMetaMembershipNodes(literal) ??
317
+ (!literal.isNegated && isApp(literal.atom, "TLA.box", 1)
318
+ ? makeExtensionNode(literal, "prop", makeRule("box_p", [formula, literal.atom.args[0]]), [
319
+ [literal.atom.args[0]],
320
+ ])
321
+ : undefined) ??
322
+ getTupleNodes(literal) ??
323
+ getRecordNodes(literal) ??
324
+ getSubsetNodes(literal) ??
325
+ []
326
+ );
327
+ };
328
+
329
+ // Zenon's newnodes_inst_bounded: instantiates \A x \in S : P and ~\E x \in S : P with the terms
330
+ // known to be in S.
331
+ const getBoundedInstances = (context: TlaContext, formula: Expr, goalness: number): Node[] => {
332
+ const exprs = context.exprs;
333
+ const index = context.index;
334
+ const makeNode = (
335
+ name: "all_in" | "notex_in",
336
+ bounded: Expr,
337
+ membership: Expr,
338
+ set: Expr,
339
+ predicate: Expr,
340
+ term: Expr,
341
+ ): Node => {
342
+ const instance =
343
+ name === "all_in" ? exprs.apply(predicate, term) : exprs.enot(exprs.apply(predicate, term));
344
+ return {
345
+ conclusions: bounded === formula ? [membership, formula] : [formula, bounded],
346
+ rule: makeRule(name, [bounded, membership, instance, set, predicate]),
347
+ priority: { instance: formula },
348
+ goalness,
349
+ branches: [[instance]],
350
+ };
351
+ };
352
+ const getTermsIn = (set: Expr) =>
353
+ index
354
+ .findPositive("TLA.in")
355
+ .map((entry) => entry[0])
356
+ .filter(
357
+ (membership): membership is RelationExpr =>
358
+ isApp(membership, "TLA.in", 2) &&
359
+ membership.args[0].metas.length === 0 &&
360
+ membership.args[1] === set,
361
+ );
362
+ if (isApp(formula, "TLA.in", 2) && formula.args[0].metas.length === 0) {
363
+ const term = formula.args[0];
364
+ const set = formula.args[1];
365
+ const universals = index
366
+ .findPositive("TLA.bAll")
367
+ .map((entry) => entry[0])
368
+ .filter(
369
+ (bounded): bounded is RelationExpr =>
370
+ isApp(bounded, "TLA.bAll", 2) && bounded.args[0] === set,
371
+ );
372
+ const existentials = index
373
+ .findNegative("TLA.bEx")
374
+ .map((entry) => entry[0])
375
+ .filter(
376
+ (bounded): bounded is NegatedRelationExpr =>
377
+ bounded.kind === "not" &&
378
+ isApp(bounded.args[0], "TLA.bEx", 2) &&
379
+ bounded.args[0].args[0] === set,
380
+ );
381
+ const notExists = existentials.map((bounded) =>
382
+ makeNode("notex_in", bounded, formula, set, bounded.args[0].args[1], term),
383
+ );
384
+ const forAll = universals.map((bounded) =>
385
+ makeNode("all_in", bounded, formula, set, bounded.args[1], term),
386
+ );
387
+ return [...forAll.reverse(), ...notExists];
388
+ }
389
+ if (isApp(formula, "TLA.bAll", 2))
390
+ return getTermsIn(formula.args[0]).map((membership) =>
391
+ makeNode("all_in", formula, membership, formula.args[0], formula.args[1], membership.args[0]),
392
+ );
393
+ if (formula.kind === "not" && isApp(formula.args[0], "TLA.bEx", 2)) {
394
+ const bounded = formula.args[0];
395
+ return getTermsIn(bounded.args[0]).map((membership) =>
396
+ makeNode(
397
+ "notex_in",
398
+ formula,
399
+ membership,
400
+ bounded.args[0],
401
+ bounded.args[1],
402
+ membership.args[0],
403
+ ),
404
+ );
405
+ }
406
+ return [];
407
+ };
408
+
409
+ const makePropositionEqualityNode = (
410
+ exprs: Expressions,
411
+ name: "p_eq_l" | "p_eq_r" | "np_eq_l" | "np_eq_r",
412
+ formula: Expr,
413
+ left: Expr,
414
+ right: Expr,
415
+ goalness: number,
416
+ ): Node => {
417
+ const isNegated = name === "np_eq_l" || name === "np_eq_r";
418
+ const isLeft = name === "p_eq_l" || name === "np_eq_l";
419
+ const proposition = isNegated && formula.kind === "not" ? formula.args[0] : formula;
420
+ const equality = equal(exprs, left, right);
421
+ const differ = exprs.enot(equal(exprs, proposition, isLeft ? left : right));
422
+ const other = isLeft ? right : left;
423
+ const rest = isNegated ? exprs.enot(other) : other;
424
+ return {
425
+ conclusions: [formula, equality],
426
+ rule: makeRule(
427
+ name,
428
+ isNegated
429
+ ? [formula, equality, differ, rest, proposition, left, right]
430
+ : [formula, equality, differ, other, formula, left, right],
431
+ ),
432
+ priority: "arity_eq",
433
+ goalness,
434
+ branches: [[differ], [rest]],
435
+ };
436
+ };
437
+
438
+ const getPropositionEqualityNodes = (context: TlaContext, formula: Expr, goalness: number) => {
439
+ const exprs = context.exprs;
440
+ const index = context.index;
441
+ const atom = formula.kind === "not" ? formula.args[0] : formula;
442
+ if (atom.kind !== "app") return [];
443
+ const isNegated = formula.kind === "not";
444
+ const make = (isLeft: boolean) => (entry: [RelationExpr, number]) =>
445
+ makePropositionEqualityNode(
446
+ exprs,
447
+ isNegated ? (isLeft ? "np_eq_l" : "np_eq_r") : isLeft ? "p_eq_l" : "p_eq_r",
448
+ formula,
449
+ entry[0].args[0],
450
+ entry[0].args[1],
451
+ goalness,
452
+ );
453
+ return [
454
+ ...index.findTransLeft("=", atom.symbol).map(make(true)),
455
+ ...index.findTransRight("=", atom.symbol).map(make(false)),
456
+ ];
457
+ };
458
+
459
+ const getEqualityPropositionNodes = (
460
+ context: TlaContext,
461
+ formula: Expr,
462
+ isLeft: boolean,
463
+ ): Node[] => {
464
+ const exprs = context.exprs;
465
+ if (!isApp(formula, "=", 2)) return [];
466
+ const term = formula.args[isLeft ? 0 : 1];
467
+ if (term.kind !== "app") return [];
468
+ const index = context.index;
469
+ const make = (isNegated: boolean) => (entry: [Expr, number]) =>
470
+ makePropositionEqualityNode(
471
+ exprs,
472
+ isNegated ? (isLeft ? "np_eq_l" : "np_eq_r") : isLeft ? "p_eq_l" : "p_eq_r",
473
+ entry[0],
474
+ formula.args[0],
475
+ formula.args[1],
476
+ entry[1],
477
+ );
478
+ return [
479
+ ...index.findPositive(term.symbol).map(make(false)),
480
+ ...index.findNegative(term.symbol).map(make(true)),
481
+ ];
482
+ };
483
+
484
+ interface ExtensionNodes {
485
+ nodes: Node[];
486
+ isStopped: boolean;
487
+ }
488
+
489
+ export const getExtensionNodes = (
490
+ context: TlaContext,
491
+ formula: Expr,
492
+ goalness: number,
493
+ ): ExtensionNodes => {
494
+ // OCaml evaluates the operands of @ right to left, so the last rules run first. The order
495
+ // decides the names of fresh variables.
496
+ const bounded = getBoundedInstances(context, formula, goalness);
497
+ const right = getEqualityPropositionNodes(context, formula, false);
498
+ const left = getEqualityPropositionNodes(context, formula, true);
499
+ const propositions = getPropositionEqualityNodes(context, formula, goalness);
500
+ const rewrites = getRewriteNodes(context, formula, goalness);
501
+ const props = getPropNodes(context, formula, goalness);
502
+ const items = [...props, ...rewrites, ...propositions, ...left, ...right, ...bounded];
503
+ const stop = items.indexOf("stop");
504
+ const kept = stop === -1 ? items : items.slice(0, stop);
505
+ return { nodes: kept.filter((item): item is Node => item !== "stop"), isStopped: stop !== -1 };
506
+ };
@@ -2,7 +2,7 @@ import { createJavaOverrideError, defineStateOperator, getValue } from "./builti
2
2
  import { TlaModuleError } from "./errors";
3
3
  import type { Builtin, BuiltinArgument } from "./evaluate";
4
4
  import type { CheckerRuntime } from "./runtime";
5
- import { getEnumeratedFactors, getRandomSubset, type JavaRandom } from "./tlc-random";
5
+ import { getEnumeratedFactors, getRandomSubset, type JavaRandom } from "./tlc/random";
6
6
  import {
7
7
  createSet,
8
8
  createTuple,
package/src/resolve.ts CHANGED
@@ -36,7 +36,7 @@ export type SymbolKind =
36
36
 
37
37
  // range is where SANY reports the symbol, and two symbols at one range are one node to SANY. params
38
38
  // holds the arity of each parameter of a defined operator.
39
- export interface Binding {
39
+ interface Binding {
40
40
  kind: SymbolKind;
41
41
  arity: number;
42
42
  params?: number[];
package/src/runtime.ts CHANGED
@@ -1,6 +1,6 @@
1
- import { createJavaRandom, getTlcFingerprint, type JavaRandom } from "./tlc-random";
1
+ import { createJavaRandom, getTlcFingerprint, type JavaRandom } from "./tlc/random";
2
2
  import { createFunction, createRecord, type Value } from "./values";
3
- import type { TlcVersion } from "./tlc-version";
3
+ import type { TlcVersion } from "./tlc/version";
4
4
 
5
5
  export interface CheckerRuntime {
6
6
  getLevel: (state: (Value | undefined)[]) => number;
@@ -1,4 +1,4 @@
1
- import type { FormalParamNode, LevelFields, OpDefNode, SanyLocation } from "./sany-nodes";
1
+ import type { FormalParamNode, LevelFields, OpDefNode, SanyLocation } from "./nodes";
2
2
 
3
3
  // tla2sany.semantic.BuiltInOperators: name, arity, level, maximum argument levels and argument
4
4
  // weights. SANY leaves the levels of "." and \neg unset.
@@ -1,5 +1,5 @@
1
- import { TEMPORAL_LEVEL } from "./levels";
2
- import type { TlcVersion } from "./tlc-version";
1
+ import { TEMPORAL_LEVEL } from "../levels";
2
+ import type { TlcVersion } from "../tlc/version";
3
3
  import type {
4
4
  AssumeProve,
5
5
  Assumption,
@@ -18,18 +18,18 @@ import type {
18
18
  SourceLocation,
19
19
  Theorem,
20
20
  UseOrHide,
21
- } from "./ast";
22
- import { getChildren } from "./ast";
21
+ } from "../ast";
22
+ import { getChildren } from "../ast";
23
23
  import {
24
24
  TlaMissingModuleError,
25
25
  TlaSanyFatalError,
26
26
  TlaSyntaxError,
27
27
  TlaUnsupportedError,
28
- } from "./errors";
29
- import { parseSanyModule } from "./parser";
30
- import { BUILTIN_LOCATION, createBuiltins, createLevelFields } from "./sany-builtins";
31
- import { getSany174LexicalError } from "./sany-lexer";
32
- import { getSanyParseError } from "./sany-parse-error";
28
+ } from "../errors";
29
+ import { parseSanyModule } from "../parser";
30
+ import { BUILTIN_LOCATION, createBuiltins, createLevelFields } from "./builtins";
31
+ import { getSany174LexicalError } from "./lexer";
32
+ import { getSanyParseError } from "./parse-error";
33
33
  import {
34
34
  addSanyMessage,
35
35
  CONSTANT_DECL_KIND,
@@ -73,13 +73,13 @@ import {
73
73
  type TheoremNode,
74
74
  type ThmOrAssumpDefNode,
75
75
  type UseOrHideNode,
76
- } from "./sany-nodes";
76
+ } from "./nodes";
77
77
  import {
78
78
  createSelectorResolver,
79
79
  getSelectorItems,
80
80
  isGeneralId,
81
81
  type SelectorItem,
82
- } from "./sany-selectors";
82
+ } from "./selectors";
83
83
  import {
84
84
  createSourceFile,
85
85
  findNameTokens,
@@ -99,8 +99,8 @@ import {
99
99
  isToken,
100
100
  type SourceFile,
101
101
  type TokenSpan,
102
- } from "./sany-source";
103
- import { SANY_OPERATOR_SYNONYMS } from "./tlc-modules";
102
+ } from "./source";
103
+ import { SANY_OPERATOR_SYNONYMS } from "../tlc/jar-data";
104
104
 
105
105
  const SYNONYMS = new Map(
106
106
  SANY_OPERATOR_SYNONYMS.flatMap(([canonical, ...synonyms]) =>
@@ -161,7 +161,7 @@ export interface SanySpecification {
161
161
  messages: SanyMessage[];
162
162
  }
163
163
 
164
- export interface SanyGenerationOptions {
164
+ interface SanyGenerationOptions {
165
165
  // The name of the root module's file, which SANY requires to match the module's name.
166
166
  rootFileName?: string;
167
167
  // The path of the root module's file as SANY's caller gives it, which SANY names when it cannot
@@ -1,4 +1,4 @@
1
- import { ACTION_LEVEL, CONSTANT_LEVEL, TEMPORAL_LEVEL, VARIABLE_LEVEL } from "./levels";
1
+ import { ACTION_LEVEL, CONSTANT_LEVEL, TEMPORAL_LEVEL, VARIABLE_LEVEL } from "../levels";
2
2
  import {
3
3
  addSanyMessage,
4
4
  CONSTANT_DECL_KIND,
@@ -25,7 +25,7 @@ import {
25
25
  type Subst,
26
26
  type SymbolNode,
27
27
  type ThmOrAssumpDefNode,
28
- } from "./sany-nodes";
28
+ } from "./nodes";
29
29
 
30
30
  // A port of the levelCheck methods of SANY's semantic nodes: the levels, weights and Leibniz flags
31
31
  // its XMLExporter writes, and the level errors it reports. Each check returns what SANY's returns,
@@ -1,4 +1,4 @@
1
- import { TlaError } from "./errors";
1
+ import { TlaError } from "../errors";
2
2
 
3
3
  // An emulation of the token manager that JavaCC generates for SANY's grammar, javacc/tla+.jj: the
4
4
  // tokens it produces, their kinds in TLAplusParserConstants order, and their positions.
@@ -5,7 +5,7 @@ import {
5
5
  type OpApplNode,
6
6
  type SanyMessage,
7
7
  type SemanticNode,
8
- } from "./sany-nodes";
8
+ } from "./nodes";
9
9
 
10
10
  // A port of SANY's tla2sany.linter.Linter, which warns about a record field named like a
11
11
  // definition or declaration of the module.
@@ -1,5 +1,5 @@
1
- import type { TlcVersion } from "./tlc-version";
2
- import { REAL_TIME, REALS, TOOLBOX } from "./bundled-modules";
1
+ import type { TlcVersion } from "../tlc/version";
2
+ import { REAL_TIME, REALS, TOOLBOX } from "../bundled-modules";
3
3
 
4
4
  const BAGS = `----------------------------- MODULE Bags --------------------------------
5
5
  (**************************************************************************)
@@ -1,5 +1,5 @@
1
- import { createSanyLexer, escapeLexeme, getKind, type SanyToken } from "./sany-lexer";
2
- import { SANY_OPERATOR_SYNONYMS } from "./tlc-modules";
1
+ import { createSanyLexer, escapeLexeme, getKind, type SanyToken } from "./lexer";
2
+ import { SANY_OPERATOR_SYNONYMS } from "../tlc/jar-data";
3
3
 
4
4
  // The report SANY's parser, TLAplusParser, gives for a module it fails to parse. This interprets
5
5
  // the grammar of javacc/tla+.jj the way the code JavaCC generates from it runs: the productions,