tla-ts 0.0.4-dev.a0009b7 → 0.0.4-dev.b254db0

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 (313) hide show
  1. package/README.md +33 -143
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +37 -1
  6. package/dist/index.d.ts +37 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +996 -0
  15. package/dist/prove.js +996 -0
  16. package/dist/run-cli.cjs +37 -47
  17. package/dist/run-cli.js +37 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +26 -7
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +63 -20
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +265 -55
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +47 -37
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +38 -61
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +78 -45
  35. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  36. package/src/{obligation-generate.ts → obligations/generate.ts} +147 -74
  37. package/src/{obligations.ts → obligations/index.ts} +29 -13
  38. package/src/{obligation-levels.ts → obligations/levels.ts} +14 -5
  39. package/src/{obligation-module.ts → obligations/module.ts} +56 -33
  40. package/src/obligations/pickle.ts +98 -0
  41. package/src/obligations/pragma.ts +189 -0
  42. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  43. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  44. package/src/{obligation-source.ts → obligations/source.ts} +159 -97
  45. package/src/obligations/temporal.ts +319 -0
  46. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  47. package/src/ocaml-marshal.ts +166 -0
  48. package/src/parallel-worker.ts +2 -18
  49. package/src/parallel.ts +10 -43
  50. package/src/prove/decide-pool.ts +100 -0
  51. package/src/prove/deciders.ts +33 -0
  52. package/src/prove/isabelle/LICENSE +36 -0
  53. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  54. package/src/prove/isabelle/decide.ts +47 -0
  55. package/src/prove/isabelle/encode.ts +503 -0
  56. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  57. package/src/prove/isabelle/isar/method.ts +367 -0
  58. package/src/prove/isabelle/isar/proof.ts +28 -0
  59. package/src/prove/isabelle/isar/statement.ts +57 -0
  60. package/src/prove/isabelle/isar/theory.ts +192 -0
  61. package/src/prove/isabelle/isar/type-check.ts +278 -0
  62. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  63. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  64. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  65. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  66. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  67. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  68. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  69. package/src/prove/isabelle/provers/classical.ts +389 -0
  70. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  71. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  72. package/src/prove/isabelle/pure/consts.ts +32 -0
  73. package/src/prove/isabelle/pure/conv.ts +79 -0
  74. package/src/prove/isabelle/pure/drule.ts +264 -0
  75. package/src/prove/isabelle/pure/envir.ts +363 -0
  76. package/src/prove/isabelle/pure/goal.ts +53 -0
  77. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  78. package/src/prove/isabelle/pure/list.ts +12 -0
  79. package/src/prove/isabelle/pure/logic.ts +402 -0
  80. package/src/prove/isabelle/pure/name.ts +110 -0
  81. package/src/prove/isabelle/pure/net.ts +262 -0
  82. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  83. package/src/prove/isabelle/pure/pattern.ts +650 -0
  84. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  85. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  86. package/src/prove/isabelle/pure/search.ts +68 -0
  87. package/src/prove/isabelle/pure/seq.ts +156 -0
  88. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  89. package/src/prove/isabelle/pure/table.ts +208 -0
  90. package/src/prove/isabelle/pure/tactic.ts +276 -0
  91. package/src/prove/isabelle/pure/tactical.ts +347 -0
  92. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  93. package/src/prove/isabelle/pure/term.ts +808 -0
  94. package/src/prove/isabelle/pure/thm.ts +806 -0
  95. package/src/prove/isabelle/pure/type.ts +133 -0
  96. package/src/prove/isabelle/pure/unify.ts +753 -0
  97. package/src/prove/isabelle/pure/variable.ts +25 -0
  98. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  99. package/src/prove/isabelle/tla/context.ts +74 -0
  100. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  101. package/src/prove/isabelle/tla/logic.ts +215 -0
  102. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  103. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  104. package/src/prove/ocaml.ts +22 -0
  105. package/src/prove/prep/action.ts +521 -0
  106. package/src/prove/prep/defs.ts +33 -0
  107. package/src/prove/prep/elab.ts +156 -0
  108. package/src/prove/prep/enabled-axioms.ts +189 -0
  109. package/src/prove/prep/enabled.ts +43 -0
  110. package/src/prove/prep/fingerprint.ts +388 -0
  111. package/src/prove/prep/flatten.ts +70 -0
  112. package/src/prove/prep/level-comparison.ts +557 -0
  113. package/src/prove/prep/md5.ts +67 -0
  114. package/src/prove/prep/pragma.ts +221 -0
  115. package/src/prove/prep/trivial.ts +22 -0
  116. package/src/prove/prove-worker.ts +25 -0
  117. package/src/prove/prove.ts +505 -0
  118. package/src/prove/ptl/decide.ts +68 -0
  119. package/src/prove/ptl/encode.ts +256 -0
  120. package/src/prove/ptl/sat.ts +151 -0
  121. package/src/prove/ptl/tableau.ts +276 -0
  122. package/src/prove/smt/axiomatize.ts +69 -0
  123. package/src/prove/smt/axioms.ts +222 -0
  124. package/src/prove/smt/context.ts +108 -0
  125. package/src/prove/smt/data.ts +636 -0
  126. package/src/prove/smt/encode.ts +166 -0
  127. package/src/prove/smt/extensionality.ts +65 -0
  128. package/src/prove/smt/flatten.ts +112 -0
  129. package/src/prove/smt/format.ts +154 -0
  130. package/src/prove/smt/instances.ts +182 -0
  131. package/src/prove/smt/rewrite.ts +773 -0
  132. package/src/prove/smt/simplify.ts +57 -0
  133. package/src/prove/smt/solver/act-cache.ts +265 -0
  134. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  135. package/src/prove/smt/solver/array.ts +22 -0
  136. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  137. package/src/prove/smt/solver/ast-lt.ts +157 -0
  138. package/src/prove/smt/solver/ast-util.ts +147 -0
  139. package/src/prove/smt/solver/ast.ts +1315 -0
  140. package/src/prove/smt/solver/auf-solver.ts +572 -0
  141. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  142. package/src/prove/smt/solver/cg-table.ts +175 -0
  143. package/src/prove/smt/solver/clause.ts +276 -0
  144. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  145. package/src/prove/smt/solver/context.ts +1292 -0
  146. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  147. package/src/prove/smt/solver/der.ts +224 -0
  148. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  149. package/src/prove/smt/solver/e-matching.ts +659 -0
  150. package/src/prove/smt/solver/enode.ts +259 -0
  151. package/src/prove/smt/solver/expr-ref.ts +21 -0
  152. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  153. package/src/prove/smt/solver/fingerprints.ts +92 -0
  154. package/src/prove/smt/solver/flat-literals.ts +51 -0
  155. package/src/prove/smt/solver/goal.ts +138 -0
  156. package/src/prove/smt/solver/hash.ts +173 -0
  157. package/src/prove/smt/solver/hashtable.ts +166 -0
  158. package/src/prove/smt/solver/internalizer.ts +1381 -0
  159. package/src/prove/smt/solver/lbool.ts +5 -0
  160. package/src/prove/smt/solver/literal.ts +24 -0
  161. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  162. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  163. package/src/prove/smt/solver/lp/containers.ts +296 -0
  164. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  165. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  166. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  167. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  168. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  169. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  170. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  171. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  172. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  173. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  174. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  175. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  176. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  177. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  178. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  179. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  180. package/src/prove/smt/solver/lp/nex.ts +120 -0
  181. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  182. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  183. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  184. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  185. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  186. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  187. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  188. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  189. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  190. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  191. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  192. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  193. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  194. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  195. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  196. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  197. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  198. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  199. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  200. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  201. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  202. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  203. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  204. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  205. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  206. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  207. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  208. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  209. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  210. package/src/prove/smt/solver/model-checker.ts +347 -0
  211. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  212. package/src/prove/smt/solver/model-finder.ts +155 -0
  213. package/src/prove/smt/solver/model-generator.ts +97 -0
  214. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  215. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  216. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  217. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  218. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  219. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  220. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  221. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  222. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  223. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  224. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  225. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  226. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  227. package/src/prove/smt/solver/nnf.ts +469 -0
  228. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  229. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  230. package/src/prove/smt/solver/propagate-values.ts +83 -0
  231. package/src/prove/smt/solver/proto-model.ts +551 -0
  232. package/src/prove/smt/solver/pull-quant.ts +139 -0
  233. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  234. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  235. package/src/prove/smt/solver/qe-lite.ts +381 -0
  236. package/src/prove/smt/solver/qi-queue.ts +362 -0
  237. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  238. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  239. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  240. package/src/prove/smt/solver/random-gen.ts +10 -0
  241. package/src/prove/smt/solver/rational.ts +165 -0
  242. package/src/prove/smt/solver/ref-vector.ts +62 -0
  243. package/src/prove/smt/solver/relevancy.ts +247 -0
  244. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  245. package/src/prove/smt/solver/rewriter.ts +843 -0
  246. package/src/prove/smt/solver/rlimit.ts +79 -0
  247. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  248. package/src/prove/smt/solver/solver.ts +71 -0
  249. package/src/prove/smt/solver/sort.ts +35 -0
  250. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  251. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  252. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  253. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  254. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  255. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  256. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  257. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  258. package/src/prove/smt/solver/theory-lra.ts +56 -0
  259. package/src/prove/smt/solver/var-subst.ts +258 -0
  260. package/src/prove/smt/solver/z3-license.txt +10 -0
  261. package/src/prove/smt/table.ts +170 -0
  262. package/src/prove/tlapm/tlapm.ts +96 -0
  263. package/src/prove/tlaps-module.ts +510 -0
  264. package/src/prove/verdict.ts +18 -0
  265. package/src/prove/zenon/LICENSE +32 -0
  266. package/src/prove/zenon/check/check.ts +105 -0
  267. package/src/prove/zenon/check/definitions.ts +144 -0
  268. package/src/prove/zenon/check/equality.ts +182 -0
  269. package/src/prove/zenon/check/functions.ts +62 -0
  270. package/src/prove/zenon/check/keys.ts +125 -0
  271. package/src/prove/zenon/check/propositional.ts +104 -0
  272. package/src/prove/zenon/check/records.ts +188 -0
  273. package/src/prove/zenon/check/relations.ts +121 -0
  274. package/src/prove/zenon/check/rewrites.ts +224 -0
  275. package/src/prove/zenon/check/sets.ts +302 -0
  276. package/src/prove/zenon/check/terms.ts +127 -0
  277. package/src/prove/zenon/check/tla.ts +126 -0
  278. package/src/prove/zenon/decide.ts +113 -0
  279. package/src/prove/zenon/encode.ts +437 -0
  280. package/src/prove/zenon/eqrel.ts +300 -0
  281. package/src/prove/zenon/equality-rules.ts +435 -0
  282. package/src/prove/zenon/expr.ts +551 -0
  283. package/src/prove/zenon/index-table.ts +350 -0
  284. package/src/prove/zenon/isar-case.ts +513 -0
  285. package/src/prove/zenon/isar.ts +1249 -0
  286. package/src/prove/zenon/limits.ts +15 -0
  287. package/src/prove/zenon/llproof.ts +173 -0
  288. package/src/prove/zenon/mltoll.ts +1566 -0
  289. package/src/prove/zenon/node.ts +297 -0
  290. package/src/prove/zenon/ocaml.ts +169 -0
  291. package/src/prove/zenon/parse.ts +247 -0
  292. package/src/prove/zenon/phrase.ts +191 -0
  293. package/src/prove/zenon/proof.ts +198 -0
  294. package/src/prove/zenon/propositional-rules.ts +387 -0
  295. package/src/prove/zenon/rules.ts +94 -0
  296. package/src/prove/zenon/search.ts +288 -0
  297. package/src/prove/zenon/tla/functions.ts +151 -0
  298. package/src/prove/zenon/tla/llproof.ts +480 -0
  299. package/src/prove/zenon/tla/records.ts +225 -0
  300. package/src/prove/zenon/tla/rewrites.ts +447 -0
  301. package/src/prove/zenon/tla/sets.ts +304 -0
  302. package/src/prove/zenon/tla/terms.ts +181 -0
  303. package/src/prove/zenon/tla/tla.ts +506 -0
  304. package/src/run-cli.ts +334 -75
  305. package/src/standard-modules.ts +5 -2
  306. package/src/successors.ts +24 -5
  307. package/src/tlapm-cache.ts +236 -0
  308. package/src/tlc-random.ts +55 -32
  309. package/src/tlc-version.ts +8 -7
  310. package/src/values.ts +97 -47
  311. package/src/worker.ts +65 -0
  312. package/dist/parallel.cjs +0 -12
  313. package/dist/parallel.js +0 -12
@@ -0,0 +1,276 @@
1
+ // Ported from Isabelle2025's Pure/tactic.ML, the basic resolution tactics. Copyright (c) 1986-2025
2
+ // University of Cambridge, Technische Universitaet Muenchen, and contributors, see LICENSE.
3
+
4
+ import { cutRl, makeElim, thinRl } from "./drule";
5
+ import { checkInterrupt, type Limits } from "./interrupt";
6
+ import { stripAssumsConcl, stripAssumsHyp } from "./logic";
7
+ import { insertTermNet, unifyTermNet, deleteTermSafe, emptyNet, type Net } from "./net";
8
+ import {
9
+ assumption,
10
+ bicompose,
11
+ biresolution,
12
+ conclOf,
13
+ eqAssumption,
14
+ flexflexRule,
15
+ majorPremOf,
16
+ nprems,
17
+ permutePrems,
18
+ rotateRule,
19
+ type BiresRule,
20
+ type Thm,
21
+ } from "./thm";
22
+ import {
23
+ allTac,
24
+ every,
25
+ noTac,
26
+ orElseGoal,
27
+ primitive,
28
+ primSeq,
29
+ subgoal,
30
+ thenGoal,
31
+ thenTac,
32
+ type GoalTactic,
33
+ type Tactic,
34
+ } from "./tactical";
35
+ import { eqThmProp } from "./tactical";
36
+
37
+ export const assumeTac =
38
+ (limits: Limits): GoalTactic =>
39
+ (index) =>
40
+ primSeq((state) => {
41
+ checkInterrupt(limits);
42
+ return assumption(limits, index, state);
43
+ });
44
+
45
+ export const eqAssumeTac: GoalTactic = (index) => primitive((state) => eqAssumption(index, state));
46
+
47
+ export const composeTac =
48
+ (limits: Limits, isElim: boolean, rule: Thm, subgoals: number): GoalTactic =>
49
+ (index) =>
50
+ primSeq((state) =>
51
+ bicompose(
52
+ limits,
53
+ { flatten: true, match: false, incremented: false },
54
+ { isElim, rule, subgoals },
55
+ index,
56
+ state,
57
+ ),
58
+ );
59
+
60
+ export const biresolveTac =
61
+ (limits: Limits, rules: readonly BiresRule[]): GoalTactic =>
62
+ (index) =>
63
+ primSeq((state) => {
64
+ checkInterrupt(limits);
65
+ return biresolution(limits, false, rules, index, state);
66
+ });
67
+
68
+ export const resolveTac = (limits: Limits, rules: readonly Thm[]) =>
69
+ biresolveTac(
70
+ limits,
71
+ rules.map((rule) => ({ isElim: false, rule })),
72
+ );
73
+
74
+ export const eresolveTac = (limits: Limits, rules: readonly Thm[]) =>
75
+ biresolveTac(
76
+ limits,
77
+ rules.map((rule) => ({ isElim: true, rule })),
78
+ );
79
+
80
+ export const dresolveTac = (limits: Limits, rules: readonly Thm[]) =>
81
+ eresolveTac(limits, rules.map(makeElim));
82
+
83
+ export const forwardTac = (limits: Limits, rules: readonly Thm[]) =>
84
+ thenGoal(resolveTac(limits, rules.map(makeElim)), assumeTac(limits));
85
+
86
+ export const aresTac = (limits: Limits, rules: readonly Thm[]) =>
87
+ orElseGoal(assumeTac(limits), resolveTac(limits, rules));
88
+
89
+ export const bimatchTac =
90
+ (limits: Limits, rules: readonly BiresRule[]): GoalTactic =>
91
+ (index) =>
92
+ primSeq((state) => {
93
+ checkInterrupt(limits);
94
+ return biresolution(limits, true, rules, index, state);
95
+ });
96
+
97
+ export const matchTac = (limits: Limits, rules: readonly Thm[]) =>
98
+ bimatchTac(
99
+ limits,
100
+ rules.map((rule) => ({ isElim: false, rule })),
101
+ );
102
+
103
+ export const ematchTac = (limits: Limits, rules: readonly Thm[]) =>
104
+ bimatchTac(
105
+ limits,
106
+ rules.map((rule) => ({ isElim: true, rule })),
107
+ );
108
+
109
+ export const flexflexTac = (limits: Limits): Tactic =>
110
+ primSeq((state) => flexflexRule(limits, state));
111
+
112
+ export const cutTac = (rule: Thm, index: number) =>
113
+ thenTac(
114
+ primSeq((state) =>
115
+ biresolution(undefined, false, [{ isElim: false, rule: cutRl }], index, state),
116
+ ),
117
+ primSeq((state) => biresolution(undefined, false, [{ isElim: false, rule }], index + 1, state)),
118
+ );
119
+
120
+ export const cutRulesTac = (rules: readonly Thm[], index: number) =>
121
+ every(rules.map((rule) => cutTac(rule, index)));
122
+
123
+ export const cutFactsTac = (rules: readonly Thm[], index: number) =>
124
+ cutRulesTac(
125
+ rules.filter((rule) => nprems(rule) === 0),
126
+ index,
127
+ );
128
+
129
+ export interface TaggedRule {
130
+ readonly tag: number;
131
+ readonly isElim: boolean;
132
+ readonly rule: Thm;
133
+ }
134
+
135
+ export interface NetPair<Tagged> {
136
+ readonly intro: Net<Tagged>;
137
+ readonly elim: Net<Tagged>;
138
+ }
139
+
140
+ export const emptyNetPair: NetPair<never> = { intro: emptyNet, elim: emptyNet };
141
+
142
+ // Tactic.insert_tagged_brl
143
+ export const insertTaggedBrl = <Tagged extends { isElim: boolean; rule: Thm }>(
144
+ tagged: Tagged,
145
+ netpair: NetPair<Tagged>,
146
+ ): NetPair<Tagged> =>
147
+ tagged.isElim
148
+ ? { intro: netpair.intro, elim: insertTermNet(majorPremOf(tagged.rule), tagged, netpair.elim) }
149
+ : { intro: insertTermNet(conclOf(tagged.rule), tagged, netpair.intro), elim: netpair.elim };
150
+
151
+ const eqKbrl = (left: { rule: Thm }, right: { rule: Thm }) => eqThmProp(left.rule, right.rule);
152
+
153
+ // Tactic.delete_tagged_brl
154
+ export const deleteTaggedBrl = <Tagged extends { isElim: boolean; rule: Thm }>(
155
+ brule: { isElim: boolean; rule: Thm },
156
+ netpair: NetPair<Tagged>,
157
+ ): NetPair<Tagged> => {
158
+ if (brule.isElim) {
159
+ if (nprems(brule.rule) === 0) return netpair;
160
+ return {
161
+ intro: netpair.intro,
162
+ elim: deleteTermSafe(eqKbrl, majorPremOf(brule.rule), brule as Tagged, netpair.elim),
163
+ };
164
+ }
165
+ return {
166
+ intro: deleteTermSafe(eqKbrl, conclOf(brule.rule), brule as Tagged, netpair.intro),
167
+ elim: netpair.elim,
168
+ };
169
+ };
170
+
171
+ // Library.order_list: by tag, dropping all but the last item with each tag. The lists are short,
172
+ // so this sorts them by insertion, which keeps items with equal tags in order as Isabelle's sort.
173
+ export const orderList = <Item>(items: readonly { tag: number; item: Item }[]): Item[] => {
174
+ const sorted = [...items];
175
+ for (let index = 1; index < sorted.length; index += 1) {
176
+ const entry = sorted[index];
177
+ let position = index;
178
+ for (; position > 0 && sorted[position - 1].tag > entry.tag; position -= 1)
179
+ sorted[position] = sorted[position - 1];
180
+ sorted[position] = entry;
181
+ }
182
+ const result: Item[] = [];
183
+ for (let index = 0; index < sorted.length; index += 1)
184
+ if (index + 1 === sorted.length || sorted[index + 1].tag !== sorted[index].tag)
185
+ result.push(sorted[index].item);
186
+ return result;
187
+ };
188
+
189
+ // Tactic.biresolution_from_nets_tac
190
+ export const biresolutionFromNetsTac = <Tagged extends { isElim: boolean; rule: Thm }>(
191
+ limits: Limits,
192
+ order: (rules: Tagged[]) => BiresRule[],
193
+ match: boolean,
194
+ netpair: NetPair<Tagged>,
195
+ ): GoalTactic =>
196
+ subgoal((goal, index) => {
197
+ const hyps = stripAssumsHyp(goal);
198
+ const concl = stripAssumsConcl(goal);
199
+ const rules = [
200
+ ...unifyTermNet(netpair.intro, concl),
201
+ ...hyps.flatMap((hyp) => unifyTermNet(netpair.elim, hyp)),
202
+ ];
203
+ return primSeq((state) => {
204
+ checkInterrupt(limits);
205
+ return biresolution(limits, match, order(rules), index, state);
206
+ });
207
+ });
208
+
209
+ export const orderTagged = (rules: readonly TaggedRule[]): BiresRule[] =>
210
+ orderList(
211
+ rules.map((rule) => ({ tag: rule.tag, item: { isElim: rule.isElim, rule: rule.rule } })),
212
+ );
213
+
214
+ export const biresolveFromNetsTac = (limits: Limits, netpair: NetPair<TaggedRule>) =>
215
+ biresolutionFromNetsTac(limits, orderTagged, false, netpair);
216
+
217
+ export const bimatchFromNetsTac = (limits: Limits, netpair: NetPair<TaggedRule>) =>
218
+ biresolutionFromNetsTac(limits, orderTagged, true, netpair);
219
+
220
+ // Tactic.build_net
221
+ export const buildNet = (rules: readonly Thm[]): Net<{ tag: number; rule: Thm }> =>
222
+ rules.reduceRight<Net<{ tag: number; rule: Thm }>>(
223
+ (net, rule, index) => insertTermNet(conclOf(rule), { tag: index + 1, rule }, net),
224
+ emptyNet,
225
+ );
226
+
227
+ export const resolveFromNetTac = (
228
+ limits: Limits,
229
+ net: Net<{ tag: number; rule: Thm }>,
230
+ ): GoalTactic =>
231
+ subgoal((goal, index) => {
232
+ const rules = unifyTermNet(net, stripAssumsConcl(goal));
233
+ return primSeq((state) => {
234
+ checkInterrupt(limits);
235
+ return biresolution(
236
+ limits,
237
+ false,
238
+ orderList(
239
+ rules.map((rule) => ({ tag: rule.tag, item: { isElim: false, rule: rule.rule } })),
240
+ ),
241
+ index,
242
+ state,
243
+ );
244
+ });
245
+ });
246
+
247
+ // The number of new subgoals of a rule.
248
+ export const subgoalsOfBrl = (brule: { isElim: boolean; rule: Thm }) =>
249
+ brule.isElim ? nprems(brule.rule) - 1 : nprems(brule.rule);
250
+
251
+ export const rotateTac =
252
+ (count: number): GoalTactic =>
253
+ (index) =>
254
+ count === 0 ? allTac : primitive((state) => rotateRule(count, index, state));
255
+
256
+ export const deferTac: GoalTactic = (index) =>
257
+ primitive((state) => permutePrems(index - 1, 1, state));
258
+
259
+ // Tactic.filter_prems_tac: removes the premises that fail the predicate.
260
+ export const filterPremsTac = (
261
+ limits: Limits,
262
+ predicate: (hyp: ReturnType<typeof stripAssumsConcl>) => boolean,
263
+ ): GoalTactic =>
264
+ subgoal((goal, index) => {
265
+ let tactic: GoalTactic | undefined;
266
+ let count = 0;
267
+ for (const hyp of stripAssumsHyp(goal)) {
268
+ if (predicate(hyp)) count += 1;
269
+ else {
270
+ const step = thenGoal(rotateTac(count), eresolveTac(limits, [thinRl]));
271
+ tactic = tactic === undefined ? step : thenGoal(tactic, step);
272
+ count = 0;
273
+ }
274
+ }
275
+ return tactic === undefined ? noTac : tactic(index);
276
+ });
@@ -0,0 +1,347 @@
1
+ // Ported from Isabelle2025's Pure/tactical.ML and Pure/search.ML. Copyright (c) 1986-2025
2
+ // University of Cambridge, Technische Universitaet Muenchen, and contributors, see LICENSE.
3
+
4
+ import { TlaIsabelleError } from "../../../errors";
5
+ import { aeconv } from "./envir";
6
+ import {
7
+ appendSeq,
8
+ emptySeq,
9
+ filterSeq,
10
+ deferSeq,
11
+ makeSeq,
12
+ mapsSeq,
13
+ ofCell,
14
+ singleSeq,
15
+ type Cell,
16
+ type Seq,
17
+ } from "./seq";
18
+ import { cons, type List } from "./list";
19
+ import { aconv } from "./term";
20
+ import { nprems, premOf, type Thm } from "./thm";
21
+
22
+ export type Tactic = (state: Thm) => Seq<Thm>;
23
+ export type GoalTactic = (index: number) => Tactic;
24
+
25
+ export const allTac: Tactic = (state) => singleSeq(state);
26
+ export const noTac: Tactic = () => emptySeq;
27
+
28
+ export const thenTac =
29
+ (first: Tactic, second: Tactic): Tactic =>
30
+ (state) =>
31
+ mapsSeq(second, first(state));
32
+
33
+ export const orElse =
34
+ (first: Tactic, second: Tactic): Tactic =>
35
+ (state) => {
36
+ const cell = first(state).pull();
37
+ return cell === undefined ? second(state) : ofCell(cell);
38
+ };
39
+
40
+ export const appendTac =
41
+ (first: Tactic, second: Tactic): Tactic =>
42
+ (state) =>
43
+ appendSeq(
44
+ first(state),
45
+ deferSeq(() => second(state)),
46
+ );
47
+
48
+ export const thenElse =
49
+ (test: Tactic, onSuccess: Tactic, onFailure: Tactic): Tactic =>
50
+ (state) => {
51
+ const cell = test(state).pull();
52
+ return cell === undefined ? onFailure(state) : mapsSeq(onSuccess, ofCell(cell));
53
+ };
54
+
55
+ export const thenGoal =
56
+ (first: GoalTactic, second: GoalTactic): GoalTactic =>
57
+ (index) =>
58
+ thenTac(first(index), second(index));
59
+
60
+ export const orElseGoal =
61
+ (first: GoalTactic, second: GoalTactic): GoalTactic =>
62
+ (index) =>
63
+ orElse(first(index), second(index));
64
+
65
+ export const appendGoal =
66
+ (first: GoalTactic, second: GoalTactic): GoalTactic =>
67
+ (index) =>
68
+ appendTac(first(index), second(index));
69
+
70
+ export const determ =
71
+ (tactic: Tactic): Tactic =>
72
+ (state) =>
73
+ makeSeq(() => {
74
+ const cell = tactic(state).pull();
75
+ return cell === undefined ? undefined : [cell[0], emptySeq];
76
+ });
77
+
78
+ export const tryTac = (tactic: Tactic) => orElse(tactic, allTac);
79
+
80
+ // Thm.eq_thm: equal hypotheses, flex-flex pairs and propositions.
81
+ export const eqThm = (left: Thm, right: Thm) =>
82
+ left === right ||
83
+ (aconv(left.prop, right.prop) &&
84
+ left.hyps.length === right.hyps.length &&
85
+ left.hyps.every((hyp) => right.hyps.some((other) => aconv(hyp, other))) &&
86
+ left.tpairs.length === right.tpairs.length &&
87
+ left.tpairs.every(
88
+ (pair, index) =>
89
+ aconv(pair[0], right.tpairs[index][0]) && aconv(pair[1], right.tpairs[index][1]),
90
+ ));
91
+
92
+ export const eqThmProp = (left: Thm, right: Thm) => aconv(left.prop, right.prop);
93
+
94
+ interface Trail {
95
+ readonly state: Thm;
96
+ readonly rest: Seq<Thm>;
97
+ readonly tactics: readonly Tactic[];
98
+ }
99
+
100
+ // EVERY: tac1 THEN ... THEN tacn, without backtracking over repeated states.
101
+ export const every = (tactics: readonly Tactic[]): Tactic => {
102
+ const evy = (trail: readonly Trail[], remaining: readonly Tactic[], state: Thm): Seq<Thm> => {
103
+ if (remaining.length === 0) return makeSeq(() => [state, makeSeq(() => evyBack(trail).pull())]);
104
+ const cell = remaining[0](state).pull();
105
+ if (cell === undefined) return evyBack(trail);
106
+ return evy(
107
+ [{ state: cell[0], rest: cell[1], tactics: remaining.slice(1) }, ...trail],
108
+ remaining.slice(1),
109
+ cell[0],
110
+ );
111
+ };
112
+ const evyBack = (trail: readonly Trail[]): Seq<Thm> => {
113
+ let current = trail;
114
+ while (current.length > 0) {
115
+ const top = current[0];
116
+ const cell = top.rest.pull();
117
+ if (cell === undefined) current = current.slice(1);
118
+ else if (eqThm(top.state, cell[0]))
119
+ current = [{ ...top, rest: cell[1] }, ...current.slice(1)];
120
+ else
121
+ return evy(
122
+ [{ state: cell[0], rest: cell[1], tactics: top.tactics }, ...current.slice(1)],
123
+ top.tactics,
124
+ cell[0],
125
+ );
126
+ }
127
+ return emptySeq;
128
+ };
129
+ return (state) => evy([], tactics, state);
130
+ };
131
+
132
+ export const everyGoal =
133
+ (tactics: readonly GoalTactic[]): GoalTactic =>
134
+ (index) =>
135
+ every(tactics.map((tactic) => tactic(index)));
136
+
137
+ export const first = (tactics: readonly Tactic[]): Tactic =>
138
+ tactics.reduceRight((rest, tactic) => orElse(tactic, rest), noTac);
139
+
140
+ export const firstGoal =
141
+ (tactics: readonly GoalTactic[]): GoalTactic =>
142
+ (index) =>
143
+ first(tactics.map((tactic) => tactic(index)));
144
+
145
+ export const repeatDetermN =
146
+ (count: number, tactic: Tactic): Tactic =>
147
+ (state) =>
148
+ makeSeq(() => {
149
+ let current = state;
150
+ let remaining = count;
151
+ while (remaining !== 0) {
152
+ const cell = tactic(current).pull();
153
+ if (cell === undefined) break;
154
+ current = cell[0];
155
+ remaining -= 1;
156
+ }
157
+ return [current, emptySeq];
158
+ });
159
+
160
+ export const repeatDeterm = (tactic: Tactic) => repeatDetermN(-1, tactic);
161
+
162
+ export const repeat =
163
+ (tactic: Tactic): Tactic =>
164
+ (start) => {
165
+ const rep = (stack: readonly Seq<Thm>[], state: Thm): Cell<Thm> => {
166
+ let current = state;
167
+ let queue = stack;
168
+ for (;;) {
169
+ const cell = tactic(current).pull();
170
+ if (cell === undefined) {
171
+ const saved = queue;
172
+ return [current, makeSeq(() => repq(saved))];
173
+ }
174
+ queue = [cell[1], ...queue];
175
+ current = cell[0];
176
+ }
177
+ };
178
+ const repq = (stack: readonly Seq<Thm>[]): Cell<Thm> => {
179
+ let queue = stack;
180
+ while (queue.length > 0) {
181
+ const cell = queue[0].pull();
182
+ if (cell !== undefined) return rep([cell[1], ...queue.slice(1)], cell[0]);
183
+ queue = queue.slice(1);
184
+ }
185
+ return undefined;
186
+ };
187
+ return makeSeq(() => rep([], start));
188
+ };
189
+
190
+ export const repeatDeterm1 = (tactic: Tactic) => thenTac(determ(tactic), repeatDeterm(tactic));
191
+ export const repeat1 = (tactic: Tactic) => thenTac(tactic, repeat(tactic));
192
+
193
+ export const filterTac =
194
+ (predicate: (state: Thm) => boolean, tactic: Tactic): Tactic =>
195
+ (state) =>
196
+ filterSeq(predicate, tactic(state));
197
+
198
+ export const changed =
199
+ (tactic: Tactic): Tactic =>
200
+ (state) =>
201
+ filterSeq((result) => !eqThm(state, result), tactic(state));
202
+
203
+ export const changedProp =
204
+ (tactic: Tactic): Tactic =>
205
+ (state) =>
206
+ filterSeq((result) => !eqThmProp(state, result), tactic(state));
207
+
208
+ export const allGoals =
209
+ (tactic: GoalTactic): Tactic =>
210
+ (state) => {
211
+ const doall = (index: number): Tactic =>
212
+ index === 0 ? allTac : thenTac(tactic(index), doall(index - 1));
213
+ return doall(nprems(state))(state);
214
+ };
215
+
216
+ export const someGoal =
217
+ (tactic: GoalTactic): Tactic =>
218
+ (state) => {
219
+ const find = (index: number): Tactic =>
220
+ index === 0 ? noTac : orElse(tactic(index), find(index - 1));
221
+ return find(nprems(state))(state);
222
+ };
223
+
224
+ export const firstGoalTac =
225
+ (tactic: GoalTactic): Tactic =>
226
+ (state) => {
227
+ const count = nprems(state);
228
+ const find = (index: number): Tactic =>
229
+ index > count ? noTac : orElse(tactic(index), find(index + 1));
230
+ return find(1)(state);
231
+ };
232
+
233
+ export const repeatSome = (tactic: GoalTactic) =>
234
+ repeat1(someGoal((index) => repeat1(tactic(index))));
235
+ export const repeatFirst = (tactic: GoalTactic) =>
236
+ repeat1(firstGoalTac((index) => repeat1(tactic(index))));
237
+ export const repeatDetermFirst = (tactic: GoalTactic) =>
238
+ repeatDeterm1(firstGoalTac((index) => repeatDeterm1(tactic(index))));
239
+ export const tryAll = (tactic: GoalTactic) => allGoals((index) => tryTac(tactic(index)));
240
+
241
+ const isThmError = (error: unknown) =>
242
+ error instanceof TlaIsabelleError && error.exception === "THM";
243
+
244
+ // SUBGOAL: a tactic built from goal index of the state, failing if there is no such goal.
245
+ export const subgoal =
246
+ (build: (goal: ReturnType<typeof premOf>, index: number) => Tactic): GoalTactic =>
247
+ (index) =>
248
+ (state) => {
249
+ if (index < 1 || index > nprems(state)) return emptySeq;
250
+ return build(premOf(state, index), index)(state);
251
+ };
252
+
253
+ export const changedGoal =
254
+ (tactic: GoalTactic): GoalTactic =>
255
+ (index) =>
256
+ (state) => {
257
+ if (index < 1 || index > nprems(state)) return emptySeq;
258
+ const goal = premOf(state, index);
259
+ const distance = nprems(state) - index;
260
+ return filterSeq((result) => {
261
+ const count = nprems(result);
262
+ return count - distance <= 0 || !aeconv(goal, premOf(result, count - distance));
263
+ }, tactic(index)(state));
264
+ };
265
+
266
+ export const solvedGoal =
267
+ (tactic: GoalTactic): GoalTactic =>
268
+ (index) =>
269
+ (state) =>
270
+ filterSeq((result) => nprems(result) < nprems(state), tactic(index)(state));
271
+
272
+ // Seq.INTERVAL: applies tactic to goals last down to first.
273
+ const interval = (tactic: GoalTactic, firstIndex: number, lastIndex: number): Tactic =>
274
+ lastIndex < firstIndex
275
+ ? allTac
276
+ : thenTac(tactic(lastIndex), interval(tactic, firstIndex, lastIndex - 1));
277
+
278
+ export const thenAllNew =
279
+ (first: GoalTactic, second: GoalTactic): GoalTactic =>
280
+ (index) =>
281
+ (state) =>
282
+ thenTac(first(index), (result) =>
283
+ interval(second, index, index + nprems(result) - nprems(state))(result),
284
+ )(state);
285
+
286
+ export const repeatAllNew = (tactic: GoalTactic): GoalTactic =>
287
+ thenAllNew(tactic, (index) => tryTac(repeatAllNew(tactic)(index)));
288
+
289
+ export const primSeq =
290
+ (apply: (state: Thm) => Seq<Thm>): Tactic =>
291
+ (state) => {
292
+ try {
293
+ return apply(state);
294
+ } catch (error) {
295
+ if (isThmError(error)) return emptySeq;
296
+ throw error;
297
+ }
298
+ };
299
+
300
+ export const primitive = (apply: (state: Thm) => Thm): Tactic =>
301
+ primSeq((state) => singleSeq(apply(state)));
302
+
303
+ export const condTac =
304
+ (test: (state: Thm) => boolean, onTrue: Tactic, onFalse: Tactic): Tactic =>
305
+ (state) =>
306
+ test(state) ? onTrue(state) : onFalse(state);
307
+
308
+ // Search.DEPTH_FIRST: depth-first search for a state satisfying the test. The stack of
309
+ // alternatives and the states already returned are lists, as in Isabelle, since the stack can grow
310
+ // as deep as the search goes.
311
+ export const depthFirst = (test: (state: Thm) => boolean, tactic: Tactic): Tactic => {
312
+ const isUsed = (used: List<Thm> | undefined, state: Thm) => {
313
+ for (let current = used; current !== undefined; current = current.tail)
314
+ if (eqThm(current.head, state)) return true;
315
+ return false;
316
+ };
317
+ const depth = (used: List<Thm> | undefined, stack: List<Seq<Thm>> | undefined): Cell<Thm> => {
318
+ let current = stack;
319
+ while (current !== undefined) {
320
+ const cell = current.head.pull();
321
+ if (cell === undefined) {
322
+ current = current.tail;
323
+ continue;
324
+ }
325
+ const state = cell[0];
326
+ const rest = cons(cell[1], current.tail);
327
+ if (test(state) && !isUsed(used, state))
328
+ return [state, makeSeq(() => depth(cons(state, used), rest))];
329
+ current = cons(tactic(state), rest);
330
+ }
331
+ return undefined;
332
+ };
333
+ return (state) => makeSeq(() => depth(undefined, cons(singleSeq(state), undefined)));
334
+ };
335
+
336
+ export const hasFewerPrems = (count: number) => (state: Thm) => nprems(state) < count;
337
+
338
+ // Search.DEPTH_SOLVE_1: depth-first search until one goal fewer remains.
339
+ export const depthSolve1 =
340
+ (tactic: Tactic): Tactic =>
341
+ (state) => {
342
+ const count = nprems(state);
343
+ return count === 0 ? emptySeq : depthFirst(hasFewerPrems(count), tactic)(state);
344
+ };
345
+
346
+ // Search.DEPTH_SOLVE: depth-first search until no goals remain.
347
+ export const depthSolve = (tactic: Tactic) => depthFirst(hasFewerPrems(1), tactic);