tla-ts 0.0.4 → 0.0.5-dev.5b2dea1

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 (378) hide show
  1. package/README.md +38 -127
  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 +46 -12
  8. package/dist/index.d.ts +46 -12
  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 +1006 -0
  17. package/dist/prove.js +1006 -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 +76 -92
  23. package/dist/transfer.js +76 -92
  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/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1153
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +115 -721
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +43 -22
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +361 -181
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +207 -141
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +645 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +84 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +21 -22
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +39 -23
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -190
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/{tlc-version.ts → tlc/version.ts} +8 -7
  365. package/src/transfer.ts +32 -32
  366. package/src/values.ts +166 -111
  367. package/src/worker.ts +62 -0
  368. package/dist/parallel.cjs +0 -12
  369. package/dist/parallel.js +0 -12
  370. package/dist/run-cli.cjs +0 -55
  371. package/dist/run-cli.js +0 -55
  372. package/src/canonical.ts +0 -40
  373. package/src/obligation-expression.ts +0 -1060
  374. package/src/obligation-module.ts +0 -1042
  375. package/src/standard-ranges.ts +0 -116
  376. package/src/value-sources.ts +0 -29
  377. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  378. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
@@ -0,0 +1,378 @@
1
+ // A port of tlapm's Backend.Zenon: an obligation as the input of Zenon's TLA+ front end, a $hyp for
2
+ // each visible fact and a $goal, naming identifiers as Isabelle does.
3
+
4
+ import { TlapmBugError, TlaProverError, TlaUnsupportedError } from "../../errors";
5
+ import { createContext, getBoundName, popNames, pushName } from "../../obligations/printer";
6
+ import type { Bound, Builtin, Expr, Hyp, Sequent } from "../../obligations/expression";
7
+ import { format, formatDelimited, renderDoc, text, type Doc } from "../../obligations/format";
8
+ import { getUnprintableError, pickle, printFact, splitFirstBound } from "../first-order";
9
+
10
+ const SPACE = format("@ ");
11
+
12
+ const ATOMS: Partial<Record<Builtin, string>> = {
13
+ TRUE: "T.",
14
+ FALSE: "F.",
15
+ STRING: "TLA.STRING",
16
+ BOOLEAN: "(TLA.set T. F.)",
17
+ Nat: "arith.N",
18
+ Int: "arith.Z",
19
+ Real: "arith.R",
20
+ Infinity: "arith.Infinity",
21
+ Any: "TLA.Any",
22
+ };
23
+
24
+ const OPERATORS: Partial<Record<Builtin, [string, number]>> = {
25
+ Implies: ["=>", 2],
26
+ Equiv: ["<=>", 2],
27
+ Conj: ["/\\", 2],
28
+ Disj: ["\\/", 2],
29
+ Neg: ["-.", 1],
30
+ Eq: ["=", 2],
31
+ DOMAIN: ["TLA.DOMAIN", 1],
32
+ SUBSET: ["TLA.SUBSET", 1],
33
+ UNION: ["TLA.UNION", 1],
34
+ Subseteq: ["TLA.subseteq", 2],
35
+ Mem: ["TLA.in", 2],
36
+ Setminus: ["TLA.setminus", 2],
37
+ Cap: ["TLA.cap", 2],
38
+ Cup: ["TLA.cup", 2],
39
+ Plus: ["arith.add", 2],
40
+ Uminus: ["arith.minus", 1],
41
+ Times: ["arith.mul", 2],
42
+ Ratio: ["arith.div", 2],
43
+ Quotient: ["arith.euclidiv", 2],
44
+ Remainder: ["arith.mod", 2],
45
+ Exp: ["arith.power", 2],
46
+ Lteq: ["arith.le", 2],
47
+ Lt: ["arith.lt", 2],
48
+ Range: ["arith.intrange", 2],
49
+ Seq: ["TLA.Seq", 1],
50
+ Len: ["TLA.Len", 1],
51
+ BSeq: ["TLA.BSeq", 1],
52
+ Cat: ["TLA.concat", 2],
53
+ Append: ["TLA.Append", 2],
54
+ Head: ["TLA.Head", 1],
55
+ Tail: ["TLA.Tail", 1],
56
+ SubSeq: ["TLA.SubSeq", 3],
57
+ SelectSeq: ["TLA.SelectSeq", 2],
58
+ OneArg: ["TLA.oneArg", 2],
59
+ Extend: ["TLA.extend", 2],
60
+ Print: ["TLA.Print", 2],
61
+ PrintT: ["TLA.PrintT", 1],
62
+ Assert: ["TLA.Assert", 2],
63
+ JavaTime: ["TLA.JavaTime", 0],
64
+ TLCGet: ["TLA.TLCGet", 1],
65
+ TLCSet: ["TLA.TLCSet", 2],
66
+ Permutations: ["TLA.Permutations", 1],
67
+ SortSeq: ["TLA.SortSeq", 2],
68
+ RandomElement: ["TLA.RandomElement", 1],
69
+ ToString: ["TLA.ToString", 1],
70
+ };
71
+
72
+ const getSuccessors = (integer: string) => {
73
+ const count = Number.parseInt(integer, 10);
74
+ return `${"(TLA.fapply TLA.Succ ".repeat(count)}0${")".repeat(count)}`;
75
+ };
76
+
77
+ // pp_print_obligation: the text tlapm writes to the .znn file it hands Zenon, for an obligation
78
+ // that Backend.Prep has shipped. Unsupported in the goal fails the obligation and in a fact omits
79
+ // it.
80
+ export const encodeZenon = (id: number, sequent: Sequent) => {
81
+ const context = createContext();
82
+ const adjoin = (name: string) => pushName(context, pickle(name));
83
+ const bump = () => pushName(context, "");
84
+
85
+ const delimited = (args: Expr[]) => formatDelimited(args, printExpr, SPACE);
86
+ const nonatomic = (name: string, args: Expr[]) => format("(%s %a)", name, delimited(args));
87
+
88
+ // A binder's name binds in the body, and what comes before prints outside it.
89
+ const printBinder = (name: string, before: Doc, body: Expr) => {
90
+ const bound = adjoin(name);
91
+ const doc = format("%a((%s) %a))", before, bound, printExpr(body));
92
+ popNames(context, 1);
93
+ return doc;
94
+ };
95
+
96
+ const printInternal = (builtin: Builtin, args: Expr[]): Doc => {
97
+ const atom = ATOMS[builtin];
98
+ if (atom !== undefined && args.length === 0) return text(atom);
99
+ const operator = OPERATORS[builtin];
100
+ if (operator && operator[1] === args.length) return nonatomic(operator[0], args);
101
+ if (args.length === 2) {
102
+ switch (builtin) {
103
+ case "Neq":
104
+ return format("(-. %a)", nonatomic("=", args));
105
+ case "Notmem":
106
+ return format("(-. %a)", nonatomic("TLA.in", args));
107
+ case "Minus":
108
+ return nonatomic("arith.add", [
109
+ args[0],
110
+ {
111
+ kind: "Apply",
112
+ operator: { kind: "Internal", builtin: "Uminus", location: args[1].location },
113
+ args: [args[1]],
114
+ location: args[1].location,
115
+ },
116
+ ]);
117
+ case "Gteq":
118
+ return nonatomic("arith.le", args.toReversed());
119
+ case "Gt":
120
+ return nonatomic("arith.lt", args.toReversed());
121
+ }
122
+ }
123
+ if (builtin === "Unprimable" && args.length === 1) return printExpr(args[0]);
124
+ throw getUnprintableError(builtin, args.length, "Backend.Zenon.fmt_apply");
125
+ };
126
+
127
+ const printApply = (operator: Expr, args: Expr[]): Doc => {
128
+ switch (operator.kind) {
129
+ case "Ix": {
130
+ const name = getBoundName(context, operator.index);
131
+ if (operator.index <= 0 || name === undefined) throw new TlapmBugError();
132
+ return args.length === 0 ? text(name) : nonatomic(name, args);
133
+ }
134
+ case "Opaque": {
135
+ const name = pickle(operator.name);
136
+ return args.length === 0 ? text(name) : nonatomic(name, args);
137
+ }
138
+ case "Internal":
139
+ return printInternal(operator.builtin, args);
140
+ case "Lambda": {
141
+ const names = operator.params.map((param) => format("%s ", adjoin(param.name)));
142
+ const doc = format("((%a) %a)", names, printExpr(operator.body));
143
+ popNames(context, operator.params.length);
144
+ return doc;
145
+ }
146
+ default:
147
+ throw new TlapmBugError();
148
+ }
149
+ };
150
+
151
+ const printQuant = (quantifier: "Forall" | "Exists", bounds: Bound[], body: Expr): Doc => {
152
+ if (bounds.length === 0) return printExpr(body);
153
+ const split = splitFirstBound(quantifier, bounds, body);
154
+ const isForall = quantifier === "Forall";
155
+ if (split.first.domain.kind === "NoDomain")
156
+ return printBinder(split.first.name, text(isForall ? "(A. " : "(E. "), split.inner);
157
+ if (split.first.domain.kind !== "Domain") throw new TlapmBugError();
158
+ const domain = printExpr(split.first.domain.expression);
159
+ return printBinder(
160
+ split.first.name,
161
+ format("(%s %a ", isForall ? "TLA.bAll" : "TLA.bEx", domain),
162
+ split.inner,
163
+ );
164
+ };
165
+
166
+ // SetOf and Fcn take one bound, whose domain prints outside it.
167
+ const printOneBound = (name: string, bounds: Bound[], body: Expr, what: string) => {
168
+ if (bounds.length !== 1) throw new TlaUnsupportedError(`${what} (multiple declared constants)`);
169
+ const bound = bounds[0];
170
+ if (bound.domain.kind !== "Domain") throw new TlapmBugError();
171
+ return printBinder(
172
+ bound.name,
173
+ format("(%s %a ", name, printExpr(bound.domain.expression)),
174
+ body,
175
+ );
176
+ };
177
+
178
+ // A sequent inside an expression, as an implication under quantifiers.
179
+ const printNestedSequent = (sequent: Sequent): Doc => {
180
+ if (sequent.context.length === 0) return printExpr(sequent.active);
181
+ const hyp = sequent.context[0];
182
+ const printRest = () =>
183
+ printNestedSequent({ context: sequent.context.slice(1), active: sequent.active });
184
+ if (hyp.kind === "Fact") {
185
+ const fact = hyp.visibility === "Visible" ? printExpr(hyp.expression) : undefined;
186
+ bump();
187
+ const doc = fact ? format("(=> %a %a)", fact, printRest()) : printRest();
188
+ popNames(context, 1);
189
+ return doc;
190
+ }
191
+ if (hyp.kind === "Defn") throw new TlapmBugError();
192
+ const domain =
193
+ hyp.kind === "Fresh" && hyp.domain && hyp.domainVisibility === "Visible"
194
+ ? printExpr(hyp.domain)
195
+ : undefined;
196
+ const name = adjoin(hyp.name);
197
+ const doc =
198
+ hyp.kind === "Flex"
199
+ ? format("(A. ((%s) (A. ((%s') %a))))", name, name, printRest())
200
+ : domain
201
+ ? format("(TLA.bAll %a ((%s) %a))", domain, name, printRest())
202
+ : format("(A. ((%s) %a))", name, printRest());
203
+ popNames(context, 1);
204
+ return doc;
205
+ };
206
+
207
+ const printExpr = (expression: Expr): Doc => {
208
+ switch (expression.kind) {
209
+ case "Ix":
210
+ case "Internal":
211
+ case "Opaque":
212
+ case "Lambda":
213
+ return printApply(expression, []);
214
+ case "Apply":
215
+ return printApply(expression.operator, expression.args);
216
+ case "Sequent":
217
+ return printNestedSequent(expression.sequent);
218
+ case "With":
219
+ case "Parens":
220
+ return printExpr(expression.expression);
221
+ case "If":
222
+ return format(
223
+ "(TLA.cond %a %a %a)",
224
+ printExpr(expression.condition),
225
+ printExpr(expression.consequent),
226
+ printExpr(expression.alternative),
227
+ );
228
+ case "List":
229
+ if (expression.bullet === "Refs" && expression.items.length === 0)
230
+ throw new TlapmBugError();
231
+ if (expression.bullet === "Refs" && expression.items.length === 1)
232
+ return printExpr(expression.items[0]);
233
+ return format(
234
+ "(%s %a)",
235
+ expression.bullet === "Or" ? "\\/" : "/\\",
236
+ delimited(expression.items),
237
+ );
238
+ case "Quant":
239
+ return printQuant(expression.quantifier, expression.bounds, expression.body);
240
+ case "Tquant":
241
+ throw new TlaUnsupportedError("\\AA or \\EE");
242
+ case "Choose":
243
+ return expression.domain
244
+ ? printBinder(
245
+ expression.name,
246
+ format("(TLA.bChoice %a ", printExpr(expression.domain)),
247
+ expression.body,
248
+ )
249
+ : printBinder(expression.name, text("(t. "), expression.body);
250
+ case "SetSt":
251
+ return printBinder(
252
+ expression.name,
253
+ format("(TLA.subsetOf %a ", printExpr(expression.domain)),
254
+ expression.body,
255
+ );
256
+ case "SetOf":
257
+ return printOneBound("TLA.setOfAll", expression.bounds, expression.element, "Setof");
258
+ case "Fcn":
259
+ return printOneBound("TLA.Fcn", expression.bounds, expression.body, "Fcn");
260
+ case "SetEnum":
261
+ if (expression.elements.length === 0) return text("TLA.emptyset");
262
+ return [
263
+ text("(TLA.set"),
264
+ expression.elements.map((element) => format(" %a", printExpr(element))),
265
+ text(")"),
266
+ ];
267
+ case "FcnApp": {
268
+ const printedFunction = printExpr(expression.function);
269
+ return expression.args.length === 1
270
+ ? format("(TLA.fapply %a %a)", printedFunction, printExpr(expression.args[0]))
271
+ : format("(TLA.fapply %a (TLA.tuple %a))", printedFunction, delimited(expression.args));
272
+ }
273
+ case "Arrow":
274
+ return format(
275
+ "(TLA.FuncSet %a %a)",
276
+ printExpr(expression.domain),
277
+ printExpr(expression.range),
278
+ );
279
+ case "Rect":
280
+ case "Record":
281
+ return [
282
+ text(expression.kind === "Rect" ? "(TLA.recordset" : "(TLA.record"),
283
+ expression.fields.map((field) => format(' "%s" %a', field.name, printExpr(field.value))),
284
+ text(")"),
285
+ ];
286
+ case "Except": {
287
+ const spec = expression.specs[0];
288
+ if (expression.specs.length !== 1 || spec.trail.length !== 1)
289
+ throw new TlaUnsupportedError("complex EXCEPT");
290
+ const point = spec.trail[0];
291
+ const argument =
292
+ point.kind === "Dot" ? text(`"${point.field}"`) : printExpr(point.expression);
293
+ return format(
294
+ "(TLA.except %a %a %a)",
295
+ printExpr(expression.function),
296
+ argument,
297
+ printExpr(spec.value),
298
+ );
299
+ }
300
+ case "Dot":
301
+ return format('(TLA.fapply %a "%s")', printExpr(expression.expression), expression.field);
302
+ case "Tuple":
303
+ return format("(TLA.tuple %a)", delimited(expression.elements));
304
+ case "Product":
305
+ return expression.factors.length === 2
306
+ ? format(
307
+ "(TLA.prod %a %a)",
308
+ printExpr(expression.factors[0]),
309
+ printExpr(expression.factors[1]),
310
+ )
311
+ : format("(TLA.Product (TLA.tuple %a))", delimited(expression.factors));
312
+ case "Sub":
313
+ case "Tsub":
314
+ case "Fair":
315
+ throw new TlaUnsupportedError(expression.kind);
316
+ case "Case": {
317
+ const arms = formatDelimited(
318
+ expression.arms,
319
+ (arm) => format("%a %a", printExpr(arm.condition), printExpr(arm.body)),
320
+ SPACE,
321
+ );
322
+ return expression.other
323
+ ? format("(TLA.CASE %a %a)@]", arms, printExpr(expression.other))
324
+ : format("(TLA.CASE %a )", arms);
325
+ }
326
+ case "String":
327
+ return format('"%s"', expression.value);
328
+ case "Num":
329
+ if (expression.fraction !== "") throw new TlaUnsupportedError("Real number constants");
330
+ return text(getSuccessors(expression.integer));
331
+ case "Bang":
332
+ case "Let":
333
+ case "At":
334
+ throw new TlapmBugError();
335
+ }
336
+ };
337
+
338
+ const printHyp = (hyp: Hyp): Doc => {
339
+ switch (hyp.kind) {
340
+ case "Fresh": {
341
+ const domain =
342
+ hyp.domain && hyp.domainVisibility === "Visible" ? printExpr(hyp.domain) : undefined;
343
+ const name = adjoin(hyp.name);
344
+ return domain ? format('$hyp "%s_in" (TLA.in %s %a)@\n', name, name, domain) : [];
345
+ }
346
+ case "Flex":
347
+ adjoin(hyp.name);
348
+ return [];
349
+ case "Defn": {
350
+ const name = adjoin(hyp.definition.name);
351
+ return hyp.visibility === "Visible"
352
+ ? format("; usable definition %s suppressed@.", name)
353
+ : [];
354
+ }
355
+ case "Fact": {
356
+ const count = String(context.stack.length);
357
+ const fact =
358
+ hyp.visibility === "Visible"
359
+ ? printFact(context, () => printExpr(hyp.expression))
360
+ : undefined;
361
+ bump();
362
+ if (fact instanceof TlaUnsupportedError)
363
+ return format("; omitted temporal assumption : %s @.", fact.message);
364
+ return fact ? format('$hyp "v\'%s" %a@\n', count, fact) : [];
365
+ }
366
+ }
367
+ };
368
+
369
+ const doc = (() => {
370
+ try {
371
+ return [sequent.context.map(printHyp), format("$goal %a", printExpr(sequent.active))];
372
+ } catch (error) {
373
+ if (!(error instanceof TlaUnsupportedError)) throw error;
374
+ throw new TlaProverError(`Zenon: unsupported operator ${error.message}`);
375
+ }
376
+ })();
377
+ return renderDoc([format(";; obligation #%s@\n", String(id)), doc]);
378
+ };
@@ -0,0 +1,300 @@
1
+ // Ported from Zenon's eqrel.ml, as shipped in tlapm. Copyright 2004 INRIA, see LICENSE.
2
+ //
3
+ // Finds the hypotheses that make a relation reflexive, symmetric or transitive. The prover then
4
+ // reasons with those properties directly, and drops the hypotheses that only state them. The
5
+ // translation to Isar proves the properties again from the hypotheses that stated them.
6
+
7
+ import { TRUE, type Expr, type Expressions } from "./expr";
8
+
9
+ export type Direction = "left" | "right";
10
+
11
+ // Where a hypothesis states a property: the conjunct at `directions`, with the relation's
12
+ // arguments bound by the quantifiers at `variables`, counted from the outermost.
13
+ export interface Origin {
14
+ formula: Expr;
15
+ directions: Direction[];
16
+ variables: number[];
17
+ }
18
+
19
+ interface RelationInfo {
20
+ reflexive: Origin | undefined;
21
+ symmetric: Origin | undefined;
22
+ transitive: Origin | undefined;
23
+ transitiveSymmetric: Origin | undefined;
24
+ // The type of the relation's arguments.
25
+ type: string;
26
+ }
27
+
28
+ interface Bound {
29
+ name: string;
30
+ type: string;
31
+ }
32
+
33
+ // A conjunct of a hypothesis: the variables quantified around it and the literals of its
34
+ // disjunction, when they all relate two of those variables by the same symbol.
35
+ interface Leaves {
36
+ directions: Direction[];
37
+ env: Bound[];
38
+ leaves: Expr[];
39
+ type: string;
40
+ }
41
+
42
+ const getLeaves = (
43
+ exprs: Expressions,
44
+ directions: Direction[],
45
+ env: Bound[],
46
+ formula: Expr,
47
+ ): Leaves => {
48
+ const leaves: Expr[] = [];
49
+ let symbol: string | undefined = undefined;
50
+ let type = "";
51
+ const getBound = (term: Expr) =>
52
+ term.kind === "var" ? env.find((bound) => bound.name === term.symbol) : undefined;
53
+ const visitLeaf = (leaf: Expr) => {
54
+ const atom = leaf.kind === "not" ? leaf.args[0] : leaf;
55
+ if (atom.kind !== "app") return false;
56
+ const first = getBound(atom.args[0]);
57
+ const isRelation =
58
+ atom.args.length === 2 &&
59
+ (symbol === undefined || atom.symbol === symbol) &&
60
+ first !== undefined &&
61
+ getBound(atom.args[1]) !== undefined;
62
+ if (!isRelation) return false;
63
+ if (symbol === undefined) type = first.type;
64
+ symbol = atom.symbol;
65
+ leaves.unshift(leaf);
66
+ return true;
67
+ };
68
+ const visit = (disjunct: Expr): boolean => {
69
+ if (disjunct.kind === "or") return visit(disjunct.args[0]) && visit(disjunct.args[1]);
70
+ if (disjunct.kind === "imply")
71
+ return visit(exprs.enot(disjunct.args[0])) && visit(disjunct.args[1]);
72
+ if (disjunct.kind === "not") {
73
+ const operand = disjunct.args[0];
74
+ if (operand.kind === "and")
75
+ return visit(exprs.enot(operand.args[0])) && visit(exprs.enot(operand.args[1]));
76
+ if (operand.kind === "not") return visit(operand.args[0]);
77
+ if (operand.kind === "true") return true;
78
+ }
79
+ if (disjunct.kind === "false") return true;
80
+ return visitLeaf(disjunct);
81
+ };
82
+ return visit(formula)
83
+ ? { directions, env, leaves, type }
84
+ : { directions, env, leaves: [], type: "" };
85
+ };
86
+
87
+ const getConjuncts = (exprs: Expressions, formula: Expr) => {
88
+ const conjuncts: Leaves[] = [];
89
+ const visit = (directions: Direction[], env: Bound[], conjunct: Expr) => {
90
+ const left: Direction[] = [...directions, "left"];
91
+ const right: Direction[] = [...directions, "right"];
92
+ const operand = conjunct.kind === "not" ? conjunct.args[0] : undefined;
93
+ if (conjunct.kind === "and") {
94
+ visit(left, env, conjunct.args[0]);
95
+ visit(right, env, conjunct.args[1]);
96
+ } else if (conjunct.kind === "all") {
97
+ const bound = { name: conjunct.args[0].symbol, type: conjunct.symbol };
98
+ visit(directions, [bound, ...env], conjunct.args[1]);
99
+ } else if (operand?.kind === "or") {
100
+ visit(left, env, exprs.enot(operand.args[0]));
101
+ visit(right, env, exprs.enot(operand.args[1]));
102
+ } else if (operand?.kind === "imply") {
103
+ visit(left, env, operand.args[0]);
104
+ visit(right, env, exprs.enot(operand.args[1]));
105
+ } else if (operand?.kind === "ex") {
106
+ const bound = { name: operand.args[0].symbol, type: operand.symbol };
107
+ visit(directions, [bound, ...env], exprs.enot(operand.args[1]));
108
+ } else if (operand?.kind === "not") {
109
+ visit(directions, env, operand.args[0]);
110
+ } else if (conjunct.kind === "equiv") {
111
+ visit(left, env, exprs.eimply(conjunct.args[0], conjunct.args[1]));
112
+ visit(right, env, exprs.eimply(conjunct.args[1], conjunct.args[0]));
113
+ } else if (operand?.kind === "equiv") {
114
+ visit(left, env, exprs.eor(operand.args[0], operand.args[1]));
115
+ visit(right, env, exprs.eor(exprs.enot(operand.args[0]), exprs.enot(operand.args[1])));
116
+ } else conjuncts.unshift(getLeaves(exprs, directions, env, conjunct));
117
+ };
118
+ visit([], [], formula);
119
+ return conjuncts;
120
+ };
121
+
122
+ const getPair = (leaf: Expr) => {
123
+ const atom = leaf.kind === "not" ? leaf.args[0] : leaf;
124
+ const args: Expr[] = atom.args;
125
+ return [args[0].symbol, args[1].symbol];
126
+ };
127
+
128
+ // The leaves as Zenon's partition returns them: positive and negative, each reversed.
129
+ const partition = (leaves: Expr[]) => ({
130
+ positive: leaves
131
+ .filter((leaf) => leaf.kind !== "not")
132
+ .reverse()
133
+ .map(getPair),
134
+ negative: leaves
135
+ .filter((leaf) => leaf.kind === "not")
136
+ .reverse()
137
+ .map(getPair),
138
+ });
139
+
140
+ // Each check returns the variables that the translation instantiates to prove the property, or
141
+ // undefined when the conjunct doesn't state it.
142
+ const getReflexive = (leaves: Expr[]) => {
143
+ if (leaves.length !== 1 || leaves[0].kind === "not") return undefined;
144
+ const pair = getPair(leaves[0]);
145
+ return pair[0] === pair[1] ? [pair[0]] : undefined;
146
+ };
147
+
148
+ const getSymmetric = (leaves: Expr[]) => {
149
+ const parts = partition(leaves);
150
+ if (parts.positive.length !== 1 || parts.negative.length !== 1) return undefined;
151
+ const positive = parts.positive[0];
152
+ const negative = parts.negative[0];
153
+ return positive[0] === negative[1] && positive[1] === negative[0] ? negative : undefined;
154
+ };
155
+
156
+ const getTriple = (leaves: Expr[]) => {
157
+ const parts = partition(leaves);
158
+ return parts.positive.length === 1 && parts.negative.length === 2
159
+ ? { result: parts.positive[0], first: parts.negative[0], second: parts.negative[1] }
160
+ : undefined;
161
+ };
162
+
163
+ const getTransitive = (leaves: Expr[]) => {
164
+ const triple = getTriple(leaves);
165
+ if (triple === undefined) return undefined;
166
+ const result = triple.result;
167
+ const first = triple.first;
168
+ const second = triple.second;
169
+ if (first[1] === second[0] && result[0] === first[0] && result[1] === second[1])
170
+ return [result[0], first[1], result[1]];
171
+ if (second[1] === first[0] && result[0] === second[0] && result[1] === first[1])
172
+ return [result[0], first[0], result[1]];
173
+ return undefined;
174
+ };
175
+
176
+ const getTransitiveSymmetric = (leaves: Expr[]) => {
177
+ const triple = getTriple(leaves);
178
+ if (triple === undefined) return undefined;
179
+ const result = triple.result;
180
+ const first = triple.first;
181
+ const second = triple.second;
182
+ if (first[1] === second[0] && result[1] === first[0] && result[0] === second[1])
183
+ return [result[1], first[1], result[0]];
184
+ if (second[1] === first[0] && result[1] === second[0] && result[0] === first[1])
185
+ return [result[1], first[0], result[0]];
186
+ return undefined;
187
+ };
188
+
189
+ const getSymbol = (leaves: Expr[]) => {
190
+ const atom = leaves[0].kind === "not" ? leaves[0].args[0] : leaves[0];
191
+ return atom.symbol;
192
+ };
193
+
194
+ export const createRelations = (exprs: Expressions) => {
195
+ const equalityOrigin = { formula: TRUE, directions: [], variables: [] };
196
+ const relations = new Map<string, RelationInfo>([
197
+ [
198
+ "=",
199
+ {
200
+ reflexive: equalityOrigin,
201
+ symmetric: equalityOrigin,
202
+ transitive: equalityOrigin,
203
+ transitiveSymmetric: equalityOrigin,
204
+ type: "",
205
+ },
206
+ ],
207
+ ]);
208
+
209
+ const getRecord = (symbol: string) => {
210
+ const existing = relations.get(symbol);
211
+ if (existing !== undefined) return existing;
212
+ const record: RelationInfo = {
213
+ reflexive: undefined,
214
+ symmetric: undefined,
215
+ transitive: undefined,
216
+ transitiveSymmetric: undefined,
217
+ type: "",
218
+ };
219
+ relations.set(symbol, record);
220
+ return record;
221
+ };
222
+
223
+ const analyse = (formula: Expr) => {
224
+ for (const conjunct of getConjuncts(exprs, formula)) {
225
+ const leaves = conjunct.leaves;
226
+ const env = conjunct.env;
227
+ const getOrigin = (names: string[] | undefined) =>
228
+ names === undefined
229
+ ? undefined
230
+ : {
231
+ formula,
232
+ directions: conjunct.directions,
233
+ variables: names.map(
234
+ (name) => env.length - 1 - env.findIndex((bound) => bound.name === name),
235
+ ),
236
+ };
237
+ const reflexive = getOrigin(getReflexive(leaves));
238
+ const symmetric = getOrigin(getSymmetric(leaves));
239
+ const transitive = getOrigin(getTransitive(leaves));
240
+ const transitiveSymmetric = getOrigin(getTransitiveSymmetric(leaves));
241
+ if (!reflexive && !symmetric && !transitive && !transitiveSymmetric) continue;
242
+ const record = getRecord(getSymbol(leaves));
243
+ if (reflexive) record.reflexive = reflexive;
244
+ if (symmetric) record.symmetric = symmetric;
245
+ if (transitive) record.transitive = transitive;
246
+ if (transitiveSymmetric) record.transitiveSymmetric = transitiveSymmetric;
247
+ record.type = conjunct.type;
248
+ }
249
+ };
250
+
251
+ const isSubsumed = (formula: Expr) =>
252
+ getConjuncts(exprs, formula).every((conjunct) => {
253
+ const leaves = conjunct.leaves;
254
+ if (getReflexive(leaves)) return getRecord(getSymbol(leaves)).reflexive !== undefined;
255
+ if (getSymmetric(leaves)) return getRecord(getSymbol(leaves)).symmetric !== undefined;
256
+ if (getTransitive(leaves)) return getRecord(getSymbol(leaves)).transitive !== undefined;
257
+ if (getTransitiveSymmetric(leaves)) {
258
+ const record = getRecord(getSymbol(leaves));
259
+ return record.symmetric !== undefined && record.transitive !== undefined;
260
+ }
261
+ return false;
262
+ });
263
+
264
+ const get = (symbol: string) => relations.get(symbol);
265
+
266
+ return {
267
+ analyse,
268
+ isSubsumed,
269
+ isReflexive: (symbol: string) => get(symbol)?.reflexive !== undefined,
270
+ isSymmetric: (symbol: string) => {
271
+ const record = get(symbol);
272
+ return (
273
+ record !== undefined &&
274
+ (record.symmetric !== undefined ||
275
+ (record.reflexive !== undefined && record.transitiveSymmetric !== undefined))
276
+ );
277
+ },
278
+ isTransitive: (symbol: string) => {
279
+ const record = get(symbol);
280
+ return (
281
+ record !== undefined &&
282
+ (record.transitive !== undefined ||
283
+ (record.reflexive !== undefined && record.transitiveSymmetric !== undefined))
284
+ );
285
+ },
286
+ isAny: (symbol: string) => {
287
+ const record = get(symbol);
288
+ return (
289
+ record !== undefined &&
290
+ (record.reflexive !== undefined ||
291
+ record.symmetric !== undefined ||
292
+ record.transitive !== undefined)
293
+ );
294
+ },
295
+ // Where the hypotheses state a relation's properties, for the translation to Isar.
296
+ get,
297
+ };
298
+ };
299
+
300
+ export type Relations = ReturnType<typeof createRelations>;