tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.f57f64938

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 (568) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +57 -53
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +3 -0
  8. package/dist/index.d.ts +3 -0
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove.cjs +2682 -426
  13. package/dist/prove.js +2681 -425
  14. package/dist/run.cjs +45 -42
  15. package/dist/run.js +47 -44
  16. package/dist/tlapm.cjs +2 -2
  17. package/dist/tlapm.js +2 -2
  18. package/dist/transfer.cjs +42 -39
  19. package/dist/transfer.js +42 -39
  20. package/dist/worker.cjs +7 -7
  21. package/dist/worker.js +7 -7
  22. package/package.json +1 -1
  23. package/src/ast.ts +41 -36
  24. package/src/builtins.ts +4 -13
  25. package/src/check-failure.ts +116 -0
  26. package/src/check-trace.ts +282 -0
  27. package/src/check.ts +353 -549
  28. package/src/cli/options.ts +6 -31
  29. package/src/cli/shared.ts +1 -1
  30. package/src/cli/tlapm.ts +433 -70
  31. package/src/cli/tlc-arguments.ts +222 -210
  32. package/src/cli/tlc-output.ts +687 -0
  33. package/src/cli/tlc-usage.ts +1 -2
  34. package/src/cli/tlc.ts +49 -702
  35. package/src/cli/xml-exporter.ts +23 -33
  36. package/src/codegen.ts +5 -10
  37. package/src/coverage.ts +0 -2
  38. package/src/dependencies.ts +30 -14
  39. package/src/dfid.ts +16 -16
  40. package/src/environment-config.ts +315 -0
  41. package/src/environment.ts +55 -338
  42. package/src/errors.ts +33 -5
  43. package/src/evaluate.ts +5 -4
  44. package/src/exit-codes.ts +1 -0
  45. package/src/fingerprints.ts +65 -1
  46. package/src/instances.ts +47 -10
  47. package/src/json.ts +4 -7
  48. package/src/levels.ts +39 -42
  49. package/src/lexer.ts +5 -3
  50. package/src/liveness-checker.ts +553 -237
  51. package/src/liveness.ts +94 -86
  52. package/src/obligations/action.ts +14 -17
  53. package/src/obligations/anonymize.ts +37 -16
  54. package/src/obligations/enabled-axioms.ts +218 -0
  55. package/src/obligations/equality.ts +1 -3
  56. package/src/obligations/expression.ts +36 -8
  57. package/src/obligations/format.ts +0 -2
  58. package/src/obligations/generate.ts +66 -54
  59. package/src/obligations/index.ts +38 -8
  60. package/src/obligations/levels.ts +24 -11
  61. package/src/obligations/module.ts +28 -41
  62. package/src/obligations/normalize.ts +26 -14
  63. package/src/obligations/operators.ts +0 -2
  64. package/src/obligations/pragma.ts +53 -16
  65. package/src/obligations/printer.ts +43 -13
  66. package/src/obligations/proof.ts +3 -2
  67. package/src/obligations/regroup.ts +0 -2
  68. package/src/obligations/simplify.ts +55 -50
  69. package/src/obligations/source.ts +118 -74
  70. package/src/obligations/subexpression.ts +45 -18
  71. package/src/obligations/substitution.ts +1 -3
  72. package/src/obligations/temporal.ts +5 -7
  73. package/src/obligations/tuples.ts +0 -2
  74. package/src/parallel-worker.ts +10 -30
  75. package/src/parallel.ts +24 -47
  76. package/src/parser.ts +580 -180
  77. package/src/pretty-print.ts +1 -1
  78. package/src/prover/decide-pool.ts +3 -3
  79. package/src/prover/deciders.ts +12 -9
  80. package/src/prover/isabelle/decide.ts +3 -25
  81. package/src/prover/isabelle/encode.ts +72 -42
  82. package/src/prover/isabelle/isar/attrib.ts +250 -0
  83. package/src/prover/isabelle/isar/context.ts +335 -0
  84. package/src/prover/isabelle/isar/induct.ts +382 -0
  85. package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
  86. package/src/prover/isabelle/isar/method.ts +509 -212
  87. package/src/prover/isabelle/isar/proof.ts +570 -14
  88. package/src/prover/isabelle/isar/rule-cases.ts +224 -0
  89. package/src/prover/isabelle/isar/theory.ts +487 -76
  90. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  91. package/src/prover/isabelle/isar/type-check.ts +89 -14
  92. package/src/prover/isabelle/provers/blast/blast.ts +7 -65
  93. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  94. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  95. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  96. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  97. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  98. package/src/prover/isabelle/provers/clasimp.ts +0 -2
  99. package/src/prover/isabelle/provers/classical.ts +45 -20
  100. package/src/prover/isabelle/provers/hypsubst.ts +17 -28
  101. package/src/prover/isabelle/pure/bicompose.ts +9 -27
  102. package/src/prover/isabelle/pure/consts.ts +0 -2
  103. package/src/prover/isabelle/pure/conv.ts +2 -10
  104. package/src/prover/isabelle/pure/drule.ts +72 -6
  105. package/src/prover/isabelle/pure/envir.ts +0 -2
  106. package/src/prover/isabelle/pure/goal.ts +1 -3
  107. package/src/prover/isabelle/pure/logic.ts +1 -3
  108. package/src/prover/isabelle/pure/name.ts +0 -2
  109. package/src/prover/isabelle/pure/net.ts +0 -2
  110. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  111. package/src/prover/isabelle/pure/pattern.ts +0 -2
  112. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
  113. package/src/prover/isabelle/pure/rewriter.ts +6 -17
  114. package/src/prover/isabelle/pure/search.ts +0 -2
  115. package/src/prover/isabelle/pure/seq.ts +0 -2
  116. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  117. package/src/prover/isabelle/pure/table.ts +2 -3
  118. package/src/prover/isabelle/pure/tactic.ts +0 -2
  119. package/src/prover/isabelle/pure/tactical.ts +42 -37
  120. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  121. package/src/prover/isabelle/pure/term.ts +0 -2
  122. package/src/prover/isabelle/pure/thm.ts +14 -13
  123. package/src/prover/isabelle/pure/type.ts +0 -2
  124. package/src/prover/isabelle/pure/unify.ts +0 -2
  125. package/src/prover/isabelle/pure/variable.ts +0 -2
  126. package/src/prover/isabelle/tla/classical-setup.ts +18 -16
  127. package/src/prover/isabelle/tla/context.ts +58 -11
  128. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  129. package/src/prover/isabelle/tla/logic.ts +49 -21
  130. package/src/prover/isabelle/tla/simpdata.ts +1 -12
  131. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  132. package/src/prover/ocaml.ts +4 -1
  133. package/src/prover/prep/action.ts +30 -31
  134. package/src/prover/prep/enabled-axioms.ts +11 -2
  135. package/src/prover/prep/fingerprint.ts +2 -5
  136. package/src/prover/prep/methods.ts +181 -51
  137. package/src/prover/prep/normalize.ts +38 -9
  138. package/src/prover/prove.ts +395 -94
  139. package/src/prover/ptl/decide.ts +95 -50
  140. package/src/prover/ptl/encode.ts +2 -3
  141. package/src/prover/ptl/tableau.ts +28 -2
  142. package/src/prover/smt/arithmetic.ts +310 -0
  143. package/src/prover/smt/axioms.ts +12 -8
  144. package/src/prover/smt/context.ts +43 -8
  145. package/src/prover/smt/data.ts +498 -379
  146. package/src/prover/smt/encode.ts +148 -57
  147. package/src/prover/smt/extensionality.ts +5 -3
  148. package/src/prover/smt/flatten.ts +4 -6
  149. package/src/prover/smt/format.ts +28 -4
  150. package/src/prover/smt/instances.ts +7 -1
  151. package/src/prover/smt/layout.ts +91 -0
  152. package/src/prover/smt/rewrite.ts +1021 -618
  153. package/src/prover/smt/simplify.ts +441 -0
  154. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  155. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  156. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  157. package/src/prover/smt/solver/act-cache.ts +0 -1
  158. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  159. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  160. package/src/prover/smt/solver/aig.ts +889 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +613 -6
  162. package/src/prover/smt/solver/arith-terms.ts +121 -0
  163. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  164. package/src/prover/smt/solver/array-rewriter.ts +309 -0
  165. package/src/prover/smt/solver/asserted-formulas.ts +87 -16
  166. package/src/prover/smt/solver/ast-lt.ts +166 -12
  167. package/src/prover/smt/solver/ast-util.ts +160 -2
  168. package/src/prover/smt/solver/ast.ts +1427 -41
  169. package/src/prover/smt/solver/auf-solver.ts +2 -6
  170. package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
  171. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  172. package/src/prover/smt/solver/bound-manager.ts +196 -0
  173. package/src/prover/smt/solver/bound-simplifier.ts +600 -0
  174. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  175. package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
  176. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  177. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  178. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  179. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  180. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  181. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  182. package/src/prover/smt/solver/card2bv.ts +110 -0
  183. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  184. package/src/prover/smt/solver/cg-table.ts +39 -25
  185. package/src/prover/smt/solver/check-logic.ts +330 -0
  186. package/src/prover/smt/solver/clause.ts +0 -1
  187. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
  188. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  189. package/src/prover/smt/solver/context.ts +516 -115
  190. package/src/prover/smt/solver/ctx-simplify.ts +20 -10
  191. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  192. package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
  193. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  194. package/src/prover/smt/solver/demodulator.ts +786 -0
  195. package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
  196. package/src/prover/smt/solver/der.ts +38 -10
  197. package/src/prover/smt/solver/diff-neq.ts +206 -0
  198. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  199. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  200. package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
  201. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  202. package/src/prover/smt/solver/e-matching.ts +7 -8
  203. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  204. package/src/prover/smt/solver/elim-uncnstr.ts +545 -0
  205. package/src/prover/smt/solver/enode.ts +100 -3
  206. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  207. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  208. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  209. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  210. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  211. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  212. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  213. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  214. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  215. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  216. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  217. package/src/prover/smt/solver/euf/egraph.ts +907 -0
  218. package/src/prover/smt/solver/euf/euf-solver.ts +1205 -0
  219. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  220. package/src/prover/smt/solver/euf/mam.ts +1050 -0
  221. package/src/prover/smt/solver/euf/q-ematch.ts +830 -0
  222. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  223. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  224. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  225. package/src/prover/smt/solver/euf/th-solver.ts +335 -0
  226. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  227. package/src/prover/smt/solver/expr-ref.ts +0 -1
  228. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  229. package/src/prover/smt/solver/expr2polynomial.ts +146 -0
  230. package/src/prover/smt/solver/factor.ts +141 -0
  231. package/src/prover/smt/solver/fd-solver.ts +265 -0
  232. package/src/prover/smt/solver/fingerprints.ts +15 -15
  233. package/src/prover/smt/solver/fix-dl-var.ts +148 -0
  234. package/src/prover/smt/solver/flat-literals.ts +0 -1
  235. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  236. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  237. package/src/prover/smt/solver/fpa-rewriter.ts +640 -0
  238. package/src/prover/smt/solver/fpa2bv-converter.ts +2249 -0
  239. package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
  240. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  241. package/src/prover/smt/solver/goal.ts +175 -15
  242. package/src/prover/smt/solver/goal2nlsat.ts +189 -0
  243. package/src/prover/smt/solver/guard-set.ts +219 -0
  244. package/src/prover/smt/solver/hash.ts +0 -1
  245. package/src/prover/smt/solver/hashtable.ts +30 -16
  246. package/src/prover/smt/solver/inf-eps.ts +63 -0
  247. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  248. package/src/prover/smt/solver/internalizer.ts +110 -38
  249. package/src/prover/smt/solver/lackr.ts +381 -0
  250. package/src/prover/smt/solver/lbool.ts +0 -1
  251. package/src/prover/smt/solver/lia2card.ts +268 -0
  252. package/src/prover/smt/solver/lia2pb.ts +154 -0
  253. package/src/prover/smt/solver/literal.ts +0 -1
  254. package/src/prover/smt/solver/logic-tactics.ts +345 -0
  255. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  256. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  257. package/src/prover/smt/solver/lp/containers.ts +0 -1
  258. package/src/prover/smt/solver/lp/core-solver.ts +18 -3
  259. package/src/prover/smt/solver/lp/cross-nested.ts +0 -1
  260. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  261. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  262. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
  263. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  264. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  265. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
  266. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  267. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  268. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  269. package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
  270. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  271. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  272. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  273. package/src/prover/smt/solver/lp/nex-creator.ts +0 -1
  274. package/src/prover/smt/solver/lp/nex.ts +0 -1
  275. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  276. package/src/prover/smt/solver/lp/nla-basics.ts +0 -2
  277. package/src/prover/smt/solver/lp/nla-core.ts +42 -11
  278. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  279. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  280. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  281. package/src/prover/smt/solver/lp/nla-grobner.ts +9 -4
  282. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  283. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  284. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  285. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  286. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  287. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  288. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  289. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  290. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  291. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  292. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  293. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  294. package/src/prover/smt/solver/lp/nra-solver.ts +25 -4
  295. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  296. package/src/prover/smt/solver/lp/pdd-interval.ts +0 -1
  297. package/src/prover/smt/solver/lp/pdd-simplifier.ts +0 -1
  298. package/src/prover/smt/solver/lp/pdd-solver.ts +0 -2
  299. package/src/prover/smt/solver/lp/pdd.ts +2 -2
  300. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  301. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  302. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  303. package/src/prover/smt/solver/macro-finder.ts +530 -0
  304. package/src/prover/smt/solver/mam-compiler.ts +122 -90
  305. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  306. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  307. package/src/prover/smt/solver/max-cliques.ts +105 -0
  308. package/src/prover/smt/solver/maxcore.ts +309 -0
  309. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  310. package/src/prover/smt/solver/maxlex.ts +115 -0
  311. package/src/prover/smt/solver/maxsmt-base.ts +105 -0
  312. package/src/prover/smt/solver/maxsmt.ts +92 -0
  313. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  314. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  315. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  316. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  317. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  318. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  319. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  320. package/src/prover/smt/solver/model-checker.ts +18 -27
  321. package/src/prover/smt/solver/model-evaluator.ts +188 -12
  322. package/src/prover/smt/solver/model-finder.ts +12 -18
  323. package/src/prover/smt/solver/model-generator.ts +56 -29
  324. package/src/prover/smt/solver/model-macro-solver.ts +49 -46
  325. package/src/prover/smt/solver/model-printer.ts +214 -0
  326. package/src/prover/smt/solver/mpf.ts +711 -0
  327. package/src/prover/smt/solver/mus.ts +51 -0
  328. package/src/prover/smt/solver/muz/dl-context.ts +404 -0
  329. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  330. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  331. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  332. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  333. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  334. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  335. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  336. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  337. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  338. package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
  339. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  340. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  341. package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
  342. package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
  343. package/src/prover/smt/solver/muz/spacer-context.ts +1406 -0
  344. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  345. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  346. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  347. package/src/prover/smt/solver/muz/spacer-pdr.ts +218 -0
  348. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  349. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  350. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  351. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  352. package/src/prover/smt/solver/nlqsat.ts +484 -0
  353. package/src/prover/smt/solver/nlsat/algebraic.ts +125 -12
  354. package/src/prover/smt/solver/nlsat/atoms.ts +20 -6
  355. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  356. package/src/prover/smt/solver/nlsat/explain.ts +63 -23
  357. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  358. package/src/prover/smt/solver/nlsat/levelwise.ts +3 -9
  359. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  360. package/src/prover/smt/solver/nlsat/polynomial.ts +13 -6
  361. package/src/prover/smt/solver/nlsat/solver.ts +234 -36
  362. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  363. package/src/prover/smt/solver/nlsat/transcendentals.ts +367 -0
  364. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  365. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -4
  366. package/src/prover/smt/solver/nlsat/upolynomial.ts +0 -2
  367. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  368. package/src/prover/smt/solver/nnf.ts +105 -23
  369. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  370. package/src/prover/smt/solver/occf.ts +97 -0
  371. package/src/prover/smt/solver/opt-context.ts +787 -0
  372. package/src/prover/smt/solver/opt-nlsat.ts +375 -0
  373. package/src/prover/smt/solver/opt-pareto.ts +282 -0
  374. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  375. package/src/prover/smt/solver/opt-solver.ts +308 -0
  376. package/src/prover/smt/solver/opt-value.ts +55 -0
  377. package/src/prover/smt/solver/optsmt.ts +692 -0
  378. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  379. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  380. package/src/prover/smt/solver/pb-rewriter.ts +284 -0
  381. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  382. package/src/prover/smt/solver/poly-rewriter.ts +202 -57
  383. package/src/prover/smt/solver/probes.ts +512 -0
  384. package/src/prover/smt/solver/propagate-values.ts +37 -21
  385. package/src/prover/smt/solver/proto-model.ts +648 -19
  386. package/src/prover/smt/solver/pull-quant.ts +28 -12
  387. package/src/prover/smt/solver/purify-arith.ts +632 -0
  388. package/src/prover/smt/solver/qe-arith-plugin.ts +1098 -0
  389. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  390. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  391. package/src/prover/smt/solver/qe-lite.ts +37 -17
  392. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  393. package/src/prover/smt/solver/qe.ts +1498 -0
  394. package/src/prover/smt/solver/qel.ts +25 -0
  395. package/src/prover/smt/solver/qi-queue.ts +0 -1
  396. package/src/prover/smt/solver/qsat.ts +814 -0
  397. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  398. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  399. package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
  400. package/src/prover/smt/solver/quantifier-manager.ts +8 -16
  401. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  402. package/src/prover/smt/solver/random-gen.ts +0 -1
  403. package/src/prover/smt/solver/rational.ts +45 -1
  404. package/src/prover/smt/solver/recfun-decl-plugin.ts +261 -0
  405. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  406. package/src/prover/smt/solver/reduce-args.ts +225 -0
  407. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  408. package/src/prover/smt/solver/ref-vector.ts +0 -1
  409. package/src/prover/smt/solver/relevancy.ts +1 -2
  410. package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
  411. package/src/prover/smt/solver/rewriter.ts +475 -36
  412. package/src/prover/smt/solver/rlimit.ts +25 -2
  413. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  414. package/src/prover/smt/solver/sat/big.ts +177 -0
  415. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  416. package/src/prover/smt/solver/sat/clause.ts +203 -0
  417. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  418. package/src/prover/smt/solver/sat/config.ts +122 -0
  419. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  420. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  421. package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
  422. package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
  423. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  424. package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
  425. package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
  426. package/src/prover/smt/solver/sat/probing.ts +170 -0
  427. package/src/prover/smt/solver/sat/sat-tactic.ts +43 -0
  428. package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
  429. package/src/prover/smt/solver/sat/scc.ts +142 -0
  430. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  431. package/src/prover/smt/solver/sat/solver.ts +2127 -0
  432. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  433. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  434. package/src/prover/smt/solver/search-tree.ts +284 -0
  435. package/src/prover/smt/solver/seq-axioms.ts +1010 -0
  436. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  437. package/src/prover/smt/solver/seq-derive.ts +1301 -0
  438. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  439. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  440. package/src/prover/smt/solver/seq-factory.ts +89 -0
  441. package/src/prover/smt/solver/seq-monadic.ts +728 -0
  442. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  443. package/src/prover/smt/solver/seq-re-rewriter.ts +1170 -0
  444. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  445. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  446. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  447. package/src/prover/smt/solver/seq-rewriter.ts +2402 -0
  448. package/src/prover/smt/solver/seq-skolem.ts +317 -0
  449. package/src/prover/smt/solver/seq-subset.ts +165 -0
  450. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  451. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  452. package/src/prover/smt/solver/smt-kernel.ts +83 -0
  453. package/src/prover/smt/solver/smt-logics.ts +66 -0
  454. package/src/prover/smt/solver/smt-setup.ts +496 -0
  455. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  456. package/src/prover/smt/solver/smtlib-parser.ts +3126 -316
  457. package/src/prover/smt/solver/smtlib-script.ts +1631 -0
  458. package/src/prover/smt/solver/solve-eqs.ts +929 -0
  459. package/src/prover/smt/solver/solver.ts +113 -22
  460. package/src/prover/smt/solver/static-features.ts +314 -0
  461. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  462. package/src/prover/smt/solver/tactic.ts +1986 -0
  463. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  464. package/src/prover/smt/solver/theory-array.ts +1240 -0
  465. package/src/prover/smt/solver/theory-bv.ts +1200 -0
  466. package/src/prover/smt/solver/theory-char.ts +355 -0
  467. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  468. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  469. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  470. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  471. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
  472. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -70
  473. package/src/prover/smt/solver/theory-lra-internalize.ts +86 -27
  474. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  475. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -26
  476. package/src/prover/smt/solver/theory-lra-state.ts +6 -22
  477. package/src/prover/smt/solver/theory-lra.ts +188 -1
  478. package/src/prover/smt/solver/theory-pb.ts +934 -0
  479. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  480. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  481. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  482. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  483. package/src/prover/smt/solver/theory-seq-state.ts +871 -0
  484. package/src/prover/smt/solver/theory-seq.ts +961 -0
  485. package/src/prover/smt/solver/theory.ts +189 -0
  486. package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
  487. package/src/prover/smt/solver/var-subst.ts +36 -14
  488. package/src/prover/smt/table.ts +3 -2
  489. package/src/prover/smt/types.ts +146 -0
  490. package/src/prover/tlapm/cache.ts +50 -19
  491. package/src/prover/tlapm/tlapm.ts +15 -9
  492. package/src/prover/tlapm-library.ts +3208 -0
  493. package/src/prover/verdict.ts +9 -0
  494. package/src/prover/zenon/check/check.ts +1 -2
  495. package/src/prover/zenon/check/records.ts +1 -1
  496. package/src/prover/zenon/check/relations.ts +2 -1
  497. package/src/prover/zenon/check/rewrites.ts +2 -15
  498. package/src/prover/zenon/check/sets.ts +40 -58
  499. package/src/prover/zenon/check/terms.ts +1 -2
  500. package/src/prover/zenon/decide.ts +10 -7
  501. package/src/prover/zenon/encode.ts +0 -2
  502. package/src/prover/zenon/eqrel.ts +2 -2
  503. package/src/prover/zenon/equality-rules.ts +0 -2
  504. package/src/prover/zenon/expr.ts +7 -2
  505. package/src/prover/zenon/index-table.ts +9 -21
  506. package/src/prover/zenon/isar-case.ts +0 -2
  507. package/src/prover/zenon/isar.ts +35 -37
  508. package/src/prover/zenon/llproof.ts +2 -13
  509. package/src/prover/zenon/mltoll.ts +12 -30
  510. package/src/prover/zenon/node.ts +20 -5
  511. package/src/prover/zenon/parse.ts +9 -8
  512. package/src/prover/zenon/phrase.ts +0 -2
  513. package/src/prover/zenon/proof.ts +0 -2
  514. package/src/prover/zenon/propositional-rules.ts +0 -2
  515. package/src/prover/zenon/rules.ts +0 -2
  516. package/src/prover/zenon/search.ts +11 -19
  517. package/src/prover/zenon/tla/functions.ts +2 -4
  518. package/src/prover/zenon/tla/llproof.ts +9 -13
  519. package/src/prover/zenon/tla/records.ts +1 -8
  520. package/src/prover/zenon/tla/rewrites.ts +0 -2
  521. package/src/prover/zenon/tla/sets.ts +22 -22
  522. package/src/prover/zenon/tla/terms.ts +0 -2
  523. package/src/prover/zenon/tla/tla.ts +7 -8
  524. package/src/resolve.ts +56 -74
  525. package/src/runtime.ts +4 -0
  526. package/src/sany/generation.ts +394 -0
  527. package/src/sany/generator-def-entries.ts +210 -0
  528. package/src/sany/generator-definitions.ts +686 -0
  529. package/src/sany/generator-expressions.ts +1100 -0
  530. package/src/sany/generator-proofs.ts +662 -0
  531. package/src/sany/generator.ts +155 -2625
  532. package/src/sany/levels.ts +0 -2
  533. package/src/sany/lexer.ts +17 -16
  534. package/src/sany/linter.ts +0 -2
  535. package/src/sany/nodes.ts +2 -3
  536. package/src/sany/report.ts +3 -6
  537. package/src/sany/selectors.ts +35 -38
  538. package/src/sany/xml.ts +23 -55
  539. package/src/search.ts +205 -43
  540. package/src/simulate.ts +157 -133
  541. package/src/spec-description.ts +33 -48
  542. package/src/standard-definitions.ts +4 -0
  543. package/src/standard-modules.ts +16 -32
  544. package/src/state-graph.ts +0 -2
  545. package/src/substitution-levels.ts +5 -4
  546. package/src/successors.ts +6 -8
  547. package/src/symmetry.ts +2 -2
  548. package/src/tableau.ts +2 -2
  549. package/src/tlc/fingerprint.ts +81 -9
  550. package/src/tlc/messages.ts +20 -15
  551. package/src/tlc/random.ts +4 -4
  552. package/src/tlc/replay.ts +8 -15
  553. package/src/tlc/summary.ts +29 -14
  554. package/src/tlc/tlc-operators.ts +2 -3
  555. package/src/tlc/tlcext-operators.ts +44 -12
  556. package/src/tlc/trace-spec.ts +21 -40
  557. package/src/typed-tier.ts +6535 -0
  558. package/src/typescript/actions.ts +2 -4
  559. package/src/typescript/collections.ts +34 -20
  560. package/src/typescript/compile.ts +1 -3
  561. package/src/typescript/formula.ts +5 -3
  562. package/src/typescript/model.ts +4 -5
  563. package/src/typescript/steps.ts +20 -18
  564. package/src/values.ts +62 -152
  565. package/src/prover/isabelle/isar/statement.ts +0 -52
  566. package/src/prover/smt/solver/z3-license.txt +0 -10
  567. package/src/prover/tlaps-module.ts +0 -510
  568. package/src/prover/zenon/LICENSE +0 -32
@@ -0,0 +1,1170 @@
1
+ import { SmtInvariantError } from "../../../errors";
2
+ import {
3
+ type AstManager,
4
+ FAMILY_SEQ,
5
+ OP_AND,
6
+ OP_GE,
7
+ OP_ITE,
8
+ OP_LT,
9
+ OP_OR,
10
+ OP_RE_COMPLEMENT,
11
+ OP_RE_CONCAT,
12
+ OP_RE_DERIVATIVE,
13
+ OP_RE_DIFF,
14
+ OP_RE_INTERSECT,
15
+ OP_RE_LOOP,
16
+ OP_RE_OF_PRED,
17
+ OP_RE_OPTION,
18
+ OP_RE_PLUS,
19
+ OP_RE_POWER,
20
+ OP_RE_RANGE,
21
+ OP_RE_REVERSE,
22
+ OP_RE_STAR,
23
+ OP_RE_UNION,
24
+ OP_RE_XOR,
25
+ OP_SEQ_AT,
26
+ OP_SEQ_CONCAT,
27
+ OP_SEQ_IN_RE,
28
+ OP_SEQ_LENGTH,
29
+ OP_SEQ_NTH_I,
30
+ OP_SEQ_PREFIX,
31
+ OP_SEQ_REPLACE_ALL,
32
+ OP_SEQ_SUFFIX,
33
+ OP_SEQ_TO_RE,
34
+ OP_SEQ_UNIT,
35
+ OP_STRING_LE,
36
+ SORT_BOOL,
37
+ } from "./ast";
38
+ import { L_FALSE, L_TRUE } from "./lbool";
39
+ import { RefVector } from "./ref-vector";
40
+ import { KERNEL_REWRITER_OPTIONS, Rewriter } from "./rewriter";
41
+ import type { Rewrite } from "./rewriter-tpl";
42
+ import { isEmptySeq, mkEmptySeq, mkSeqApp } from "./seq-decl-plugin";
43
+ import { DERIVATIVE_ANTIMIROV, Derive } from "./seq-derive";
44
+ import {
45
+ intersectRanges,
46
+ rangePredicateToRegex,
47
+ regexToRangePredicate,
48
+ subtractRanges,
49
+ uniteRanges,
50
+ } from "./seq-range-predicate";
51
+ import { RegexBisim } from "./seq-regex-bisim";
52
+ import {
53
+ UINT_MAX,
54
+ canBeMember,
55
+ getLoopBounds,
56
+ getLoopLower,
57
+ getRangeChars,
58
+ ReInfoCache,
59
+ isDotPlus,
60
+ isEpsilon,
61
+ isFullChar,
62
+ isFullSeq,
63
+ isReBinary,
64
+ isReEmpty,
65
+ isReGround,
66
+ isReOp,
67
+ isReUnary,
68
+ mkEpsilon,
69
+ mkFullChar,
70
+ mkFullSeq,
71
+ mkReEmpty,
72
+ mkReLoop,
73
+ mkReRange,
74
+ } from "./seq-re-util";
75
+ import type { Result, SeqRewriter } from "./seq-rewriter";
76
+ import { isReSubset } from "./seq-subset";
77
+
78
+ const BR_REWRITE1 = 1;
79
+ const BR_REWRITE2 = 2;
80
+ const BR_REWRITE3 = 3;
81
+ const BR_REWRITE_FULL = 4;
82
+ const MAX_OP_CACHE_SIZE = 10000;
83
+
84
+ export interface BoolRewriter {
85
+ mkAnd(args: number[]): number;
86
+ mkOr(args: number[]): number;
87
+ mkNot(arg: number): number;
88
+ mkEq(left: number, right: number): number;
89
+ mkIte(condition: number, thenExpr: number, elseExpr: number): number | Rewrite;
90
+ }
91
+
92
+ interface ReSplit {
93
+ head: number;
94
+ tail: number;
95
+ }
96
+
97
+ const rewrite = (expr: number, depth: number): Rewrite => ({ expr, depth });
98
+
99
+ export const getResultExpr = (result: number | Rewrite) =>
100
+ typeof result === "number" ? result : result.expr;
101
+
102
+ export class ReRewriter {
103
+ private nullableCache = new Map<number, number>();
104
+ private opCacheTrail: RefVector;
105
+ private isInBisim = false;
106
+ private derive: Derive | undefined;
107
+ private ownBool: Rewriter | undefined;
108
+
109
+ readonly info: ReInfoCache;
110
+
111
+ constructor(
112
+ private manager: AstManager,
113
+ private seq: SeqRewriter,
114
+ private bool?: BoolRewriter,
115
+ ) {
116
+ this.info = new ReInfoCache(manager);
117
+ this.opCacheTrail = new RefVector(manager);
118
+ }
119
+
120
+ release() {
121
+ this.opCacheTrail.reset();
122
+ this.nullableCache.clear();
123
+ this.derive?.release();
124
+ if (this.ownBool !== undefined) this.ownBool.release();
125
+ this.info.release();
126
+ }
127
+
128
+ private getBool() {
129
+ if (this.bool !== undefined) return this.bool;
130
+ this.ownBool ??= new Rewriter(this.manager, KERNEL_REWRITER_OPTIONS);
131
+ return this.ownBool;
132
+ }
133
+
134
+ getDerive() {
135
+ this.derive ??= new Derive(this.manager, this);
136
+ return this.derive;
137
+ }
138
+
139
+ mkAppCore(decl: number, op: number, args: number[]): Result {
140
+ switch (op) {
141
+ case OP_RE_PLUS:
142
+ return this.mkRePlus(args[0]);
143
+ case OP_RE_STAR:
144
+ return this.mkReStar(args[0]);
145
+ case OP_RE_OPTION:
146
+ return this.mkReOpt(args[0]);
147
+ case OP_RE_REVERSE:
148
+ return this.mkReReverse(args[0]);
149
+ case OP_RE_DERIVATIVE:
150
+ return this.mkDerivative(args[0], args[1]);
151
+ case OP_RE_CONCAT:
152
+ return args.length === 1 ? args[0] : this.mkReConcat(args[0], args[1]);
153
+ case OP_RE_UNION:
154
+ return args.length === 1 ? args[0] : this.mkReUnion(args[0], args[1]);
155
+ case OP_RE_RANGE:
156
+ return this.mkReRange(args[0], args[1]);
157
+ case OP_RE_DIFF:
158
+ return args.length === 2
159
+ ? this.mkReDiff(args[0], args[1])
160
+ : args.length === 1
161
+ ? args[0]
162
+ : undefined;
163
+ case OP_RE_XOR:
164
+ return args.length === 2
165
+ ? this.mkReXor(args[0], args[1])
166
+ : args.length === 1
167
+ ? args[0]
168
+ : undefined;
169
+ case OP_RE_INTERSECT:
170
+ return args.length === 1 ? args[0] : this.mkReInter(args[0], args[1]);
171
+ case OP_RE_COMPLEMENT:
172
+ return this.mkReComplement(args[0]);
173
+ case OP_RE_LOOP:
174
+ return this.mkReLoop(decl, args);
175
+ case OP_RE_POWER: {
176
+ const power = this.manager.funcDecls[decl].parameters[0] >>> 0;
177
+ return this.mkLoop(args[0], power, power);
178
+ }
179
+ case OP_SEQ_TO_RE:
180
+ return this.mkStrToRegexp(args[0]);
181
+ case OP_SEQ_IN_RE:
182
+ return this.mkStrInRegexp(args[0], args[1]);
183
+ default:
184
+ return undefined;
185
+ }
186
+ }
187
+
188
+ private mkRe(op: number, args: number[], parameters: number[] = []) {
189
+ return mkSeqApp(this.manager, op, args, parameters);
190
+ }
191
+
192
+ private mkRawIte(condition: number, thenExpr: number, elseExpr: number) {
193
+ return this.manager.mkApp(
194
+ OP_ITE,
195
+ [condition, thenExpr, elseExpr],
196
+ this.manager.sorts[thenExpr],
197
+ );
198
+ }
199
+
200
+ private mkBool(op: number, args: number[]) {
201
+ return this.manager.mkApp(op, args, SORT_BOOL);
202
+ }
203
+
204
+ private mkBoolIte(condition: number, thenExpr: number, elseExpr: number) {
205
+ return getResultExpr(this.getBool().mkIte(condition, thenExpr, elseExpr));
206
+ }
207
+
208
+ private getResult(result: Result, op: number, args: number[]) {
209
+ return result === undefined ? this.mkRe(op, args) : getResultExpr(result);
210
+ }
211
+
212
+ private getUnary(expr: number, op: number) {
213
+ return isReUnary(this.manager, expr, op) ? this.manager.getArg(expr, 0) : -1;
214
+ }
215
+
216
+ private getSplit(expr: number, op: number): ReSplit | undefined {
217
+ const manager = this.manager;
218
+ return isReBinary(manager, expr, op)
219
+ ? { head: manager.getArg(expr, 0), tail: manager.getArg(expr, 1) }
220
+ : undefined;
221
+ }
222
+
223
+ private getIte(expr: number) {
224
+ return this.manager.getOp(expr) === OP_ITE ? this.manager.getArgs(expr) : undefined;
225
+ }
226
+
227
+ private getSeqSort(regex: number) {
228
+ return this.manager.getReSeqSort(this.manager.sorts[regex]);
229
+ }
230
+
231
+ private mkEmptyOf(regex: number) {
232
+ return mkReEmpty(this.manager, this.manager.sorts[regex]);
233
+ }
234
+
235
+ private mkFullSeqOf(regex: number) {
236
+ return mkFullSeq(this.manager, this.manager.sorts[regex]);
237
+ }
238
+
239
+ private mkEqEmpty(regex: number) {
240
+ return this.manager.mkEq(regex, this.mkEmptyOf(regex));
241
+ }
242
+
243
+ mkUnion(first: number, second: number) {
244
+ return this.getResult(this.mkReUnion(first, second), OP_RE_UNION, [first, second]);
245
+ }
246
+
247
+ mkInter(first: number, second: number) {
248
+ return this.getResult(this.mkReInter(first, second), OP_RE_INTERSECT, [first, second]);
249
+ }
250
+
251
+ mkComplement(regex: number) {
252
+ return this.getResult(this.mkReComplement(regex), OP_RE_COMPLEMENT, [regex]);
253
+ }
254
+
255
+ mkToRe(seq: number) {
256
+ return this.getResult(this.mkStrToRegexp(seq), OP_SEQ_TO_RE, [seq]);
257
+ }
258
+
259
+ mkStar(regex: number) {
260
+ return this.getResult(this.mkReStar(regex), OP_RE_STAR, [regex]);
261
+ }
262
+
263
+ mkPlus(regex: number) {
264
+ return this.getResult(this.mkRePlus(regex), OP_RE_PLUS, [regex]);
265
+ }
266
+
267
+ mkOpt(regex: number) {
268
+ return this.getResult(this.mkReOpt(regex), OP_RE_OPTION, [regex]);
269
+ }
270
+
271
+ mkDiff(first: number, second: number) {
272
+ return this.getResult(this.mkReDiff(first, second), OP_RE_DIFF, [first, second]);
273
+ }
274
+
275
+ mkReverse(regex: number) {
276
+ return this.getResult(this.mkReReverse(regex), OP_RE_REVERSE, [regex]);
277
+ }
278
+
279
+ mkReAppend(first: number, second: number) {
280
+ return this.getResult(this.mkReConcat(first, second), OP_RE_CONCAT, [first, second]);
281
+ }
282
+
283
+ mkXor0(first: number, second: number) {
284
+ return this.getResult(this.mkReXor0(first, second), OP_RE_XOR, [first, second]);
285
+ }
286
+
287
+ mkReXorSimplified(first: number, second: number) {
288
+ return this.getResult(this.mkReXor(first, second), OP_RE_XOR, [first, second]);
289
+ }
290
+
291
+ mkLoop(regex: number, lo: number, hi?: number) {
292
+ return this.mkApp(this.manager.decls[mkReLoop(this.manager, regex, lo, hi)], [regex]);
293
+ }
294
+
295
+ mkApp(decl: number, args: number[]) {
296
+ const manager = this.manager;
297
+ const funcDecl = manager.funcDecls[decl];
298
+ const result = funcDecl.family === FAMILY_SEQ ? this.seq.mkAppCore(decl, args) : undefined;
299
+ return result === undefined ? manager.mkApp(decl, args, funcDecl.range) : getResultExpr(result);
300
+ }
301
+
302
+ mkSeqConcat(first: number, second: number) {
303
+ const result = this.seq.mkSeqConcat(first, second);
304
+ return result === undefined
305
+ ? mkSeqApp(this.manager, OP_SEQ_CONCAT, [first, second])
306
+ : getResultExpr(result);
307
+ }
308
+
309
+ isNullable(regex: number) {
310
+ const cached = this.nullableCache.get(regex);
311
+ if (cached !== undefined) return cached;
312
+ const result = this.getDerive().isNullable(regex);
313
+ if (this.nullableCache.size >= MAX_OP_CACHE_SIZE) {
314
+ this.opCacheTrail.reset();
315
+ this.nullableCache.clear();
316
+ }
317
+ this.opCacheTrail.push(regex);
318
+ this.opCacheTrail.push(result);
319
+ this.nullableCache.set(regex, result);
320
+ return result;
321
+ }
322
+
323
+ mkDerivative(element: number, regex: number) {
324
+ return this.getDerive().derive(DERIVATIVE_ANTIMIROV, element, regex);
325
+ }
326
+
327
+ mkSymbolicDerivative(regex: number) {
328
+ return this.getDerive().deriveSymbolic(DERIVATIVE_ANTIMIROV, regex);
329
+ }
330
+
331
+ isSubset(first: number, second: number) {
332
+ return isReSubset(this.info, first, second);
333
+ }
334
+
335
+ areComplements(first: number, second: number) {
336
+ return (
337
+ this.getUnary(first, OP_RE_COMPLEMENT) === second ||
338
+ this.getUnary(second, OP_RE_COMPLEMENT) === first
339
+ );
340
+ }
341
+
342
+ private mkReReverse(regex: number): Result {
343
+ const manager = this.manager;
344
+ const concat = this.getSplit(regex, OP_RE_CONCAT);
345
+ if (concat !== undefined) {
346
+ const tailReverse = this.mkReverse(concat.tail);
347
+ const headReverse = this.mkReverse(concat.head);
348
+ return this.mkReAppend(tailReverse, headReverse);
349
+ }
350
+ const star = this.getUnary(regex, OP_RE_STAR);
351
+ if (star !== -1) return this.mkStar(this.mkReverse(star));
352
+ const plus = this.getUnary(regex, OP_RE_PLUS);
353
+ if (plus !== -1) return this.mkPlus(this.mkReverse(plus));
354
+ const binaryOps = [OP_RE_UNION, OP_RE_INTERSECT, OP_RE_DIFF, OP_RE_XOR];
355
+ for (const op of binaryOps) {
356
+ const split = this.getSplit(regex, op);
357
+ if (split === undefined) continue;
358
+ const first = this.mkReverse(split.head);
359
+ const second = this.mkReverse(split.tail);
360
+ return op === OP_RE_UNION
361
+ ? this.mkUnion(first, second)
362
+ : op === OP_RE_INTERSECT
363
+ ? this.mkInter(first, second)
364
+ : op === OP_RE_DIFF
365
+ ? this.mkDiff(first, second)
366
+ : this.mkReXorSimplified(first, second);
367
+ }
368
+ const ite = this.getIte(regex);
369
+ if (ite !== undefined) {
370
+ const thenReverse = this.mkReverse(ite[1]);
371
+ const elseReverse = this.mkReverse(ite[2]);
372
+ return this.mkBoolIte(ite[0], thenReverse, elseReverse);
373
+ }
374
+ const opt = this.getUnary(regex, OP_RE_OPTION);
375
+ if (opt !== -1) return this.mkOpt(this.mkReverse(opt));
376
+ const complement = this.getUnary(regex, OP_RE_COMPLEMENT);
377
+ if (complement !== -1) return this.mkComplement(this.mkReverse(complement));
378
+ const loopLower = getLoopLower(manager, regex);
379
+ if (loopLower !== undefined) return this.mkLoop(this.mkReverse(loopLower.body), loopLower.lo);
380
+ const loop = getLoopBounds(manager, regex);
381
+ if (loop !== undefined) return this.mkLoop(this.mkReverse(loop.body), loop.lo, loop.hi);
382
+ const reverse = this.getUnary(regex, OP_RE_REVERSE);
383
+ if (reverse !== -1) return reverse;
384
+ if (
385
+ isFullSeq(manager, regex) ||
386
+ isReEmpty(manager, regex) ||
387
+ isReOp(manager, regex, OP_RE_RANGE) ||
388
+ isFullChar(manager, regex) ||
389
+ isReOp(manager, regex, OP_RE_OF_PRED)
390
+ )
391
+ return regex;
392
+ const seq = this.getUnary(regex, OP_SEQ_TO_RE);
393
+ if (seq === -1) return undefined;
394
+ const chars = manager.getString(seq);
395
+ if (chars !== undefined) return this.mkToRe(manager.mkString([...chars].reverse()));
396
+ if (manager.getOp(seq) === OP_SEQ_UNIT) return regex;
397
+ if (manager.getOp(seq) !== OP_SEQ_CONCAT || manager.getNumArgs(seq) !== 2) return undefined;
398
+ const tailReverse = this.mkReverse(this.mkToRe(manager.getArg(seq, 1)));
399
+ const headReverse = this.mkReverse(this.mkToRe(manager.getArg(seq, 0)));
400
+ return this.mkReAppend(tailReverse, headReverse);
401
+ }
402
+
403
+ private mkRegexUnionNormalize(first: number, second: number) {
404
+ const manager = this.manager;
405
+ if (first === second || isReEmpty(manager, second) || isFullSeq(manager, first)) return first;
406
+ if (isReEmpty(manager, first) || isFullSeq(manager, second)) return second;
407
+ if (isDotPlus(manager, first) && this.info.getInfo(second).lo > 0) return first;
408
+ if (isDotPlus(manager, second) && this.info.getInfo(first).lo > 0) return second;
409
+ const firstRange = getRangeChars(manager, first);
410
+ const secondRange = getRangeChars(manager, second);
411
+ if (
412
+ firstRange !== undefined &&
413
+ secondRange !== undefined &&
414
+ secondRange[0] <= firstRange[1] + 1 &&
415
+ firstRange[0] <= secondRange[1] + 1
416
+ )
417
+ return mkReRange(
418
+ manager,
419
+ manager.sorts[first],
420
+ Math.min(firstRange[0], secondRange[0]),
421
+ Math.max(firstRange[1], secondRange[1]),
422
+ );
423
+ return this.mergeRegexSets(
424
+ first,
425
+ second,
426
+ this.mkFullSeqOf(first),
427
+ OP_RE_UNION,
428
+ (left, right) =>
429
+ this.isSubset(left, right)
430
+ ? right
431
+ : this.isSubset(right, left)
432
+ ? left
433
+ : this.mkRe(OP_RE_UNION, [left, right]),
434
+ );
435
+ }
436
+
437
+ private mkRegexInterNormalize(inputFirst: number, inputSecond: number) {
438
+ const manager = this.manager;
439
+ const isSwapped = isEpsilon(manager, inputSecond);
440
+ const first = isSwapped ? inputSecond : inputFirst;
441
+ const second = isSwapped ? inputFirst : inputSecond;
442
+ const compose = (left: number, right: number) =>
443
+ this.isSubset(left, right)
444
+ ? left
445
+ : this.isSubset(right, left)
446
+ ? right
447
+ : this.mkRe(OP_RE_INTERSECT, [left, right]);
448
+ if (first === second || isReEmpty(manager, first) || isFullSeq(manager, second)) return first;
449
+ if (isReEmpty(manager, second) || isFullSeq(manager, first)) return second;
450
+ if (isEpsilon(manager, first)) {
451
+ const nullable = this.info.getInfo(second).nullable;
452
+ if (nullable === L_TRUE) return first;
453
+ if (nullable === L_FALSE) return this.mkEmptyOf(first);
454
+ return this.mergeRegexSets(first, second, this.mkEmptyOf(first), OP_RE_INTERSECT, compose);
455
+ }
456
+ if (isDotPlus(manager, first) && this.info.getInfo(second).lo > 0) return second;
457
+ if (isDotPlus(manager, second) && this.info.getInfo(first).lo > 0) return first;
458
+ const firstRange = getRangeChars(manager, first);
459
+ const secondRange = getRangeChars(manager, second);
460
+ if (firstRange !== undefined && secondRange !== undefined)
461
+ return mkReRange(
462
+ manager,
463
+ manager.sorts[first],
464
+ Math.max(firstRange[0], secondRange[0]),
465
+ Math.min(firstRange[1], secondRange[1]),
466
+ );
467
+ return this.mergeRegexSets(first, second, this.mkEmptyOf(first), OP_RE_INTERSECT, compose);
468
+ }
469
+
470
+ private mergeRegexSets(
471
+ first: number,
472
+ second: number,
473
+ unit: number,
474
+ op: number,
475
+ compose: (left: number, right: number) => number,
476
+ ) {
477
+ const manager = this.manager;
478
+ const prefix: number[] = [];
479
+ const getId = (expr: number) => {
480
+ const complemented = this.getUnary(expr, OP_RE_COMPLEMENT);
481
+ return manager.ids[complemented === -1 ? expr : complemented];
482
+ };
483
+ const compare = (left: number, right: number) =>
484
+ left === right ? 0 : getId(left) < getId(right) ? -1 : 1;
485
+ const composeResult = (suffix: number) => {
486
+ let result = suffix;
487
+ while (prefix.length > 0) result = compose(prefix.pop()!, result);
488
+ return result;
489
+ };
490
+ let left = first;
491
+ let right = second;
492
+ for (;;) {
493
+ if (left === right) return composeResult(left);
494
+ if (this.areComplements(left, right)) return unit;
495
+ if (this.getSplit(right, op) !== undefined && this.getSplit(left, op) === undefined)
496
+ [left, right] = [right, left];
497
+ const leftSplit = this.getSplit(left, op);
498
+ const rightSplit = this.getSplit(right, op);
499
+ if (leftSplit !== undefined && rightSplit !== undefined) {
500
+ if (this.areComplements(leftSplit.head, rightSplit.head)) return unit;
501
+ const order = compare(leftSplit.head, rightSplit.head);
502
+ if (order === 0) {
503
+ prefix.push(leftSplit.head);
504
+ left = leftSplit.tail;
505
+ right = rightSplit.tail;
506
+ } else if (order === -1) {
507
+ prefix.push(leftSplit.head);
508
+ left = leftSplit.tail;
509
+ } else {
510
+ prefix.push(rightSplit.head);
511
+ right = rightSplit.tail;
512
+ }
513
+ continue;
514
+ }
515
+ if (leftSplit !== undefined) {
516
+ if (this.areComplements(leftSplit.head, right)) return unit;
517
+ const order = compare(leftSplit.head, right);
518
+ if (order === 0) return composeResult(left);
519
+ if (order === -1) {
520
+ prefix.push(leftSplit.head);
521
+ left = leftSplit.tail;
522
+ continue;
523
+ }
524
+ prefix.push(right);
525
+ return composeResult(left);
526
+ }
527
+ if (compare(left, right) === -1) [left, right] = [right, left];
528
+ prefix.push(right);
529
+ return composeResult(left);
530
+ }
531
+ }
532
+
533
+ isReContainsPattern(regex: number): number[][] | undefined {
534
+ const manager = this.manager;
535
+ const first = this.getSplit(regex, OP_RE_CONCAT);
536
+ if (first === undefined || !isFullSeq(manager, first.head)) return undefined;
537
+ const patterns: number[][] = [[]];
538
+ let current = first.tail;
539
+ for (
540
+ let split = this.getSplit(current, OP_RE_CONCAT);
541
+ split !== undefined;
542
+ split = this.getSplit(current, OP_RE_CONCAT)
543
+ ) {
544
+ const seq = this.getUnary(split.head, OP_SEQ_TO_RE);
545
+ if (seq !== -1) patterns[patterns.length - 1].push(seq);
546
+ else if (isFullSeq(manager, split.head)) patterns.push([]);
547
+ else return undefined;
548
+ current = split.tail;
549
+ }
550
+ return isFullSeq(manager, current) ? patterns : undefined;
551
+ }
552
+
553
+ private isConcreteChar(expr: number) {
554
+ const manager = this.manager;
555
+ const chars = manager.getString(expr);
556
+ if (chars !== undefined) return chars.length === 1;
557
+ return manager.getOp(expr) === OP_SEQ_UNIT && manager.getChar(manager.getArg(expr, 0)) !== -1;
558
+ }
559
+
560
+ private mkStrInRegexp(seq: number, regex: number): Result {
561
+ const manager = this.manager;
562
+ if (isReEmpty(manager, regex)) return manager.falseExpr;
563
+ if (isFullSeq(manager, regex)) return manager.trueExpr;
564
+ const range = this.getSplit(regex, OP_RE_RANGE);
565
+ if (
566
+ range !== undefined &&
567
+ (!this.isConcreteChar(range.head) || !this.isConcreteChar(range.tail))
568
+ ) {
569
+ const one = manager.mkNumeral(1n);
570
+ const mkLengthIsOne = (expr: number) => manager.mkEq(this.mkRe(OP_SEQ_LENGTH, [expr]), one);
571
+ const conjuncts = [
572
+ mkLengthIsOne(range.head),
573
+ mkLengthIsOne(range.tail),
574
+ mkLengthIsOne(seq),
575
+ this.mkRe(OP_STRING_LE, [range.head, seq]),
576
+ this.mkRe(OP_STRING_LE, [seq, range.tail]),
577
+ ];
578
+ return rewrite(this.mkBool(OP_AND, conjuncts), BR_REWRITE_FULL);
579
+ }
580
+ const chars = manager.getString(seq);
581
+ if (chars !== undefined && isReGround(this.info, regex)) {
582
+ let current = regex;
583
+ for (const code of chars) {
584
+ if (isReEmpty(manager, current)) return manager.falseExpr;
585
+ current = this.mkDerivative(manager.mkChar(code), current);
586
+ }
587
+ const nullable = this.info.getInfo(current).nullable;
588
+ if (nullable === L_TRUE) return manager.trueExpr;
589
+ if (nullable === L_FALSE) return manager.falseExpr;
590
+ }
591
+ const isReplaceAll = manager.getOp(seq) === OP_SEQ_REPLACE_ALL && manager.getNumArgs(seq) === 3;
592
+ const replaced = isReplaceAll ? manager.getArg(seq, 0) : -1;
593
+ const source = isReplaceAll ? manager.getArg(seq, 1) : -1;
594
+ const target = isReplaceAll ? manager.getArg(seq, 2) : -1;
595
+ // Z3 returns the string x itself, which is not a Boolean.
596
+ if (isReplaceAll && source === target)
597
+ return rewrite(this.mkRe(OP_SEQ_IN_RE, [replaced, regex]), BR_REWRITE1);
598
+ const sourceChars = isReplaceAll ? manager.getString(source) : undefined;
599
+ const targetChars = isReplaceAll ? manager.getString(target) : undefined;
600
+ if (
601
+ sourceChars?.length === 1 &&
602
+ targetChars?.length === 1 &&
603
+ sourceChars[0] !== targetChars[0] &&
604
+ isReGround(this.info, regex) &&
605
+ this.info.getInfo(regex).isClassical
606
+ ) {
607
+ const newRegex = this.reReplaceChar(regex, sourceChars[0], targetChars[0], source, target);
608
+ return rewrite(this.mkRe(OP_SEQ_IN_RE, [replaced, newRegex]), BR_REWRITE_FULL);
609
+ }
610
+ const lifted = this.liftStrFromToRe(regex);
611
+ if (lifted !== undefined) return rewrite(this.getBool().mkEq(seq, lifted), BR_REWRITE_FULL);
612
+ const concat = this.getSplit(regex, OP_RE_CONCAT);
613
+ if (concat !== undefined) {
614
+ const prefix = this.getUnary(concat.head, OP_SEQ_TO_RE);
615
+ if (prefix !== -1 && isFullSeq(manager, concat.tail))
616
+ return rewrite(this.mkRe(OP_SEQ_PREFIX, [prefix, seq]), BR_REWRITE1);
617
+ const suffix = this.getUnary(concat.tail, OP_SEQ_TO_RE);
618
+ if (suffix !== -1 && isFullSeq(manager, concat.head))
619
+ return rewrite(this.mkRe(OP_SEQ_SUFFIX, [suffix, seq]), BR_REWRITE1);
620
+ }
621
+ const union = this.getSplit(regex, OP_RE_UNION);
622
+ const optional =
623
+ this.getUnary(regex, OP_RE_OPTION) !== -1
624
+ ? this.getUnary(regex, OP_RE_OPTION)
625
+ : union !== undefined && isEpsilon(manager, union.tail)
626
+ ? union.head
627
+ : union !== undefined && isEpsilon(manager, union.head)
628
+ ? union.tail
629
+ : -1;
630
+ if (optional !== -1) {
631
+ const isEmpty = manager.mkEq(this.mkRe(OP_SEQ_LENGTH, [seq]), manager.mkNumeral(0n));
632
+ const isMember = this.mkRe(OP_SEQ_IN_RE, [seq, optional]);
633
+ return rewrite(this.mkRawIte(isEmpty, manager.trueExpr, isMember), BR_REWRITE_FULL);
634
+ }
635
+ if (isEmptySeq(manager, seq)) {
636
+ const nullable = this.isNullable(regex);
637
+ return manager.getOp(nullable) === OP_SEQ_IN_RE
638
+ ? nullable
639
+ : rewrite(nullable, BR_REWRITE_FULL);
640
+ }
641
+ if (!canBeMember(this.info, seq, regex)) return manager.falseExpr;
642
+ return undefined;
643
+ }
644
+
645
+ private reReplaceChar(
646
+ regex: number,
647
+ source: number,
648
+ target: number,
649
+ sourceStr: number,
650
+ targetStr: number,
651
+ ): number {
652
+ const manager = this.manager;
653
+ const replace = (expr: number) =>
654
+ this.reReplaceChar(expr, source, target, sourceStr, targetStr);
655
+ const mkSourceOrTarget = () =>
656
+ this.mkRe(OP_RE_UNION, [
657
+ this.mkRe(OP_SEQ_TO_RE, [sourceStr]),
658
+ this.mkRe(OP_SEQ_TO_RE, [targetStr]),
659
+ ]);
660
+ const seq = this.getUnary(regex, OP_SEQ_TO_RE);
661
+ const chars = seq === -1 ? undefined : manager.getString(seq);
662
+ if (chars !== undefined) {
663
+ const parts: number[] = [];
664
+ for (const code of chars) {
665
+ if (code === source) return mkReEmpty(manager, manager.mkReSort(manager.sorts[seq]));
666
+ parts.push(
667
+ code === target
668
+ ? mkSourceOrTarget()
669
+ : this.mkRe(OP_SEQ_TO_RE, [manager.mkString([code])]),
670
+ );
671
+ }
672
+ if (parts.length === 0) return mkEpsilon(manager, manager.sorts[seq]);
673
+ let result = parts[parts.length - 1];
674
+ for (let index = parts.length - 1; index-- > 0;)
675
+ result = this.mkRe(OP_RE_CONCAT, [parts[index], result]);
676
+ return result;
677
+ }
678
+ const rangeArgs = this.getSplit(regex, OP_RE_RANGE);
679
+ if (rangeArgs !== undefined) {
680
+ const loChars = manager.getString(rangeArgs.head);
681
+ const hiChars = manager.getString(rangeArgs.tail);
682
+ if (loChars?.length !== 1 || hiChars?.length !== 1) return regex;
683
+ const lo = loChars[0];
684
+ const hi = hiChars[0];
685
+ const parts: number[] = [];
686
+ const mkRange = (from: number, to: number) =>
687
+ this.mkRe(OP_RE_RANGE, [manager.mkString([from]), manager.mkString([to])]);
688
+ if (lo <= hi) {
689
+ let previous = lo;
690
+ for (let code = lo; code <= hi; code++) {
691
+ if (code !== source && code !== target) continue;
692
+ if (previous < code) parts.push(mkRange(previous, code - 1));
693
+ if (code === target) parts.push(mkSourceOrTarget());
694
+ previous = code + 1;
695
+ }
696
+ if (previous <= hi) parts.push(mkRange(previous, hi));
697
+ }
698
+ if (parts.length === 0) return this.mkEmptyOf(regex);
699
+ let result = parts[0];
700
+ for (let index = 1; index < parts.length; index++)
701
+ result = this.mkRe(OP_RE_UNION, [result, parts[index]]);
702
+ return result;
703
+ }
704
+ for (const op of [OP_RE_UNION, OP_RE_INTERSECT, OP_RE_CONCAT]) {
705
+ const split = this.getSplit(regex, op);
706
+ if (split === undefined) continue;
707
+ const first = replace(split.head);
708
+ const second = replace(split.tail);
709
+ return this.mkRe(op, [first, second]);
710
+ }
711
+ for (const op of [OP_RE_STAR, OP_RE_PLUS, OP_RE_OPTION]) {
712
+ const body = this.getUnary(regex, op);
713
+ if (body !== -1) return this.mkRe(op, [replace(body)]);
714
+ }
715
+ const loop = getLoopBounds(manager, regex);
716
+ if (loop !== undefined) return mkReLoop(manager, replace(loop.body), loop.lo, loop.hi);
717
+ const loopLower = getLoopLower(manager, regex);
718
+ if (loopLower !== undefined) return mkReLoop(manager, replace(loopLower.body), loopLower.lo);
719
+ if (isReOp(manager, regex, OP_RE_COMPLEMENT))
720
+ throw new SmtInvariantError("a classical regular expression has no complement");
721
+ return regex;
722
+ }
723
+
724
+ private liftStrFromToRe(regex: number): number | undefined {
725
+ const seq = this.getUnary(regex, OP_SEQ_TO_RE);
726
+ if (seq !== -1) return seq;
727
+ const ite = this.getIte(regex);
728
+ if (ite === undefined) return undefined;
729
+ const thenSeq = this.liftStrFromToRe(ite[1]);
730
+ if (thenSeq === undefined) return undefined;
731
+ const elseSeq = this.liftStrFromToRe(ite[2]);
732
+ return elseSeq === undefined ? undefined : this.mkRawIte(ite[0], thenSeq, elseSeq);
733
+ }
734
+
735
+ private mkStrToRegexp(seq: number): Result {
736
+ const manager = this.manager;
737
+ if (manager.getOp(seq) !== OP_SEQ_AT || manager.getNumArgs(seq) !== 2) return undefined;
738
+ const base = manager.getArg(seq, 0);
739
+ const index = manager.getArg(seq, 1);
740
+ const zero = manager.mkNumeral(0n);
741
+ const isNonNegative = this.mkBool(OP_GE, [index, zero]);
742
+ const isBelowLength = this.mkBool(OP_LT, [index, this.mkRe(OP_SEQ_LENGTH, [base])]);
743
+ const isValid = this.mkBool(OP_AND, [isNonNegative, isBelowLength]);
744
+ const nth = this.mkRe(OP_SEQ_UNIT, [this.mkRe(OP_SEQ_NTH_I, [base, index])]);
745
+ const nonEmpty = this.mkRe(OP_SEQ_TO_RE, [nth]);
746
+ const empty = mkEpsilon(manager, manager.sorts[seq]);
747
+ return rewrite(this.mkRawIte(isValid, nonEmpty, empty), BR_REWRITE_FULL);
748
+ }
749
+
750
+ private mkReConcat(inputFirst: number, inputSecond: number): Result {
751
+ const manager = this.manager;
752
+ const isAcceptingEmptyWord = (regex: number) => {
753
+ const info = this.info.getInfo(regex);
754
+ return info.isInterpreted && info.nullable === L_TRUE && info.lo === 0;
755
+ };
756
+ const isStartingWithFullSeq = (regex: number) => {
757
+ const split = this.getSplit(regex, OP_RE_CONCAT);
758
+ return isFullSeq(manager, regex) || (split !== undefined && isFullSeq(manager, split.head));
759
+ };
760
+ const isEndingWithFullSeq = (regex: number) => {
761
+ let current = regex;
762
+ for (
763
+ let split = this.getSplit(current, OP_RE_CONCAT);
764
+ split !== undefined;
765
+ split = this.getSplit(current, OP_RE_CONCAT)
766
+ )
767
+ current = split.tail;
768
+ return isFullSeq(manager, current);
769
+ };
770
+ const isEveryInterArmEndingWithFullSeq = (regex: number) => {
771
+ const todo = [regex];
772
+ for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
773
+ const split = this.getSplit(current, OP_RE_INTERSECT);
774
+ if (split !== undefined) todo.push(split.head, split.tail);
775
+ else if (!isEndingWithFullSeq(current)) return false;
776
+ }
777
+ return true;
778
+ };
779
+ let first = inputFirst;
780
+ let second = inputSecond;
781
+ const isFirstFull = isFullSeq(manager, first);
782
+ const isSecondFull = isFullSeq(manager, second);
783
+ if (isFirstFull && isSecondFull) return first;
784
+ if (isFirstFull && isAcceptingEmptyWord(second)) return first;
785
+ if (isSecondFull && isAcceptingEmptyWord(first)) return second;
786
+ if (isSecondFull && isEndingWithFullSeq(first)) return first;
787
+ if (isFirstFull && isStartingWithFullSeq(second)) return second;
788
+ const union = this.getSplit(second, OP_RE_UNION);
789
+ if (
790
+ isFirstFull &&
791
+ union !== undefined &&
792
+ (isStartingWithFullSeq(union.head) || isStartingWithFullSeq(union.tail))
793
+ ) {
794
+ const headConcat = this.mkReAppend(first, union.head);
795
+ const tailConcat = this.mkReAppend(first, union.tail);
796
+ return rewrite(this.mkRegexUnionNormalize(headConcat, tailConcat), BR_REWRITE2);
797
+ }
798
+ if (
799
+ this.getSplit(first, OP_RE_INTERSECT) !== undefined &&
800
+ isSecondFull &&
801
+ isEveryInterArmEndingWithFullSeq(first)
802
+ )
803
+ return first;
804
+ if (isReEmpty(manager, first)) return first;
805
+ if (isReEmpty(manager, second)) return second;
806
+ if (isEpsilon(manager, first)) return second;
807
+ if (isEpsilon(manager, second)) return first;
808
+ if (isFullChar(manager, first) && isSecondFull) return this.mkPlus(first);
809
+ if (isFullChar(manager, second) && isFirstFull) return this.mkPlus(second);
810
+ const firstSeq = this.liftStrFromToRe(first);
811
+ const secondSeq = firstSeq === undefined ? undefined : this.liftStrFromToRe(second);
812
+ if (firstSeq !== undefined && secondSeq !== undefined)
813
+ return this.mkToRe(this.mkSeqConcat(firstSeq, secondSeq));
814
+ const firstStar = this.getUnary(first, OP_RE_STAR);
815
+ if (firstStar !== -1) {
816
+ if (this.getUnary(second, OP_RE_STAR) === firstStar) return first;
817
+ const secondConcat = this.getSplit(second, OP_RE_CONCAT);
818
+ if (secondConcat !== undefined && this.getUnary(secondConcat.head, OP_RE_STAR) === firstStar)
819
+ return second;
820
+ if (firstStar === second) return this.mkReAppend(second, first);
821
+ }
822
+ const firstLoop = getLoopBounds(manager, first);
823
+ const secondLoop = getLoopBounds(manager, second);
824
+ if (
825
+ firstLoop !== undefined &&
826
+ firstLoop.lo <= firstLoop.hi &&
827
+ secondLoop !== undefined &&
828
+ secondLoop.lo <= secondLoop.hi &&
829
+ firstLoop.body === secondLoop.body &&
830
+ firstLoop.hi <= UINT_MAX - secondLoop.hi
831
+ )
832
+ return this.mkLoop(
833
+ firstLoop.body,
834
+ firstLoop.lo + secondLoop.lo,
835
+ firstLoop.hi + secondLoop.hi,
836
+ );
837
+ const firstLower = getLoopLower(manager, first);
838
+ const secondLower = getLoopLower(manager, second);
839
+ if (
840
+ firstLower !== undefined &&
841
+ secondLower !== undefined &&
842
+ firstLower.body === secondLower.body &&
843
+ firstLower.lo <= UINT_MAX - secondLower.lo
844
+ )
845
+ return this.mkLoop(firstLower.body, firstLower.lo + secondLower.lo);
846
+ for (let round = 0; round < 2; round++) {
847
+ const lower = getLoopLower(manager, first);
848
+ const bounds = getLoopBounds(manager, first);
849
+ const otherBounds = getLoopBounds(manager, second);
850
+ const otherStar = this.getUnary(second, OP_RE_STAR);
851
+ if (
852
+ lower !== undefined &&
853
+ otherBounds !== undefined &&
854
+ otherBounds.lo <= otherBounds.hi &&
855
+ lower.body === otherBounds.body &&
856
+ lower.lo <= UINT_MAX - otherBounds.lo
857
+ )
858
+ return this.mkLoop(lower.body, lower.lo + otherBounds.lo);
859
+ if (bounds !== undefined && bounds.lo <= bounds.hi && bounds.body === otherStar)
860
+ return this.mkLoop(bounds.body, bounds.lo);
861
+ if (lower !== undefined && lower.body === otherStar) return first;
862
+ if (
863
+ bounds !== undefined &&
864
+ bounds.lo <= bounds.hi &&
865
+ bounds.hi < UINT_MAX &&
866
+ bounds.body === second
867
+ )
868
+ return this.mkLoop(bounds.body, bounds.lo + 1, bounds.hi + 1);
869
+ [first, second] = [second, first];
870
+ }
871
+ const firstIte = this.getIte(first);
872
+ if (firstIte !== undefined) {
873
+ const thenConcat = this.mkReAppend(firstIte[1], second);
874
+ const elseConcat = this.mkReAppend(firstIte[2], second);
875
+ return this.mkBoolIte(firstIte[0], thenConcat, elseConcat);
876
+ }
877
+ const secondIte = this.getIte(second);
878
+ if (secondIte !== undefined) {
879
+ const thenConcat = this.mkReAppend(first, secondIte[1]);
880
+ const elseConcat = this.mkReAppend(first, secondIte[2]);
881
+ return this.mkBoolIte(secondIte[0], thenConcat, elseConcat);
882
+ }
883
+ const concat = this.getSplit(first, OP_RE_CONCAT);
884
+ if (concat !== undefined)
885
+ return this.mkReAppend(concat.head, this.mkReAppend(concat.tail, second));
886
+ return undefined;
887
+ }
888
+
889
+ private tryCollapse(first: number, second: number, op: number) {
890
+ const manager = this.manager;
891
+ if (!manager.isReSort(manager.sorts[first])) return undefined;
892
+ const firstRanges = regexToRangePredicate(manager, first);
893
+ if (firstRanges === undefined) return undefined;
894
+ const secondRanges = regexToRangePredicate(manager, second);
895
+ if (secondRanges === undefined) return undefined;
896
+ const ranges =
897
+ op === OP_RE_UNION
898
+ ? uniteRanges(firstRanges, secondRanges)
899
+ : op === OP_RE_INTERSECT
900
+ ? intersectRanges(firstRanges, secondRanges)
901
+ : subtractRanges(firstRanges, secondRanges);
902
+ return rangePredicateToRegex(manager, ranges, this.getSeqSort(first));
903
+ }
904
+
905
+ private mkReUnion(first: number, second: number): Result {
906
+ return (
907
+ this.tryCollapse(first, second, OP_RE_UNION) ?? this.mkRegexUnionNormalize(first, second)
908
+ );
909
+ }
910
+
911
+ private mkReComplement(regex: number): Result {
912
+ const manager = this.manager;
913
+ const inter = this.getSplit(regex, OP_RE_INTERSECT);
914
+ if (inter !== undefined) {
915
+ const first = this.mkComplement(inter.head);
916
+ const second = this.mkComplement(inter.tail);
917
+ return this.mkUnion(first, second);
918
+ }
919
+ const union = this.getSplit(regex, OP_RE_UNION);
920
+ if (union !== undefined) {
921
+ const first = this.mkComplement(union.head);
922
+ const second = this.mkComplement(union.tail);
923
+ return this.mkInter(first, second);
924
+ }
925
+ if (isReEmpty(manager, regex)) return this.mkFullSeqOf(regex);
926
+ if (isFullSeq(manager, regex)) return this.mkEmptyOf(regex);
927
+ const complement = this.getUnary(regex, OP_RE_COMPLEMENT);
928
+ if (complement !== -1) return complement;
929
+ if (isEpsilon(manager, regex)) return this.mkPlus(mkFullChar(manager, manager.sorts[regex]));
930
+ const ite = this.getIte(regex);
931
+ if (ite === undefined) return undefined;
932
+ const thenComplement = this.mkComplement(ite[1]);
933
+ const elseComplement = this.mkComplement(ite[2]);
934
+ return this.mkBoolIte(ite[0], thenComplement, elseComplement);
935
+ }
936
+
937
+ private mkReInter(first: number, second: number): Result {
938
+ return (
939
+ this.tryCollapse(first, second, OP_RE_INTERSECT) ?? this.mkRegexInterNormalize(first, second)
940
+ );
941
+ }
942
+
943
+ private mkReDiff(first: number, second: number): Result {
944
+ return (
945
+ this.tryCollapse(first, second, OP_RE_DIFF) ?? this.mkInter(first, this.mkComplement(second))
946
+ );
947
+ }
948
+
949
+ private mkReXor0(first: number, second: number): Result {
950
+ if (first === second) return this.mkEmptyOf(first);
951
+ if (isReEmpty(this.manager, first)) return second;
952
+ if (isReEmpty(this.manager, second)) return first;
953
+ return undefined;
954
+ }
955
+
956
+ private mkReXor(first: number, second: number): Result {
957
+ const manager = this.manager;
958
+ const reduced = this.mkReXor0(first, second);
959
+ if (reduced !== undefined) return reduced;
960
+ if (isFullSeq(manager, first)) return this.mkComplement(second);
961
+ if (isFullSeq(manager, second)) return this.mkComplement(first);
962
+ const firstComplement = this.getUnary(first, OP_RE_COMPLEMENT);
963
+ const secondComplement = this.getUnary(second, OP_RE_COMPLEMENT);
964
+ if (firstComplement !== -1 && secondComplement !== -1)
965
+ return this.mkReXorSimplified(firstComplement, secondComplement);
966
+ if (firstComplement !== -1)
967
+ return this.mkComplement(this.mkReXorSimplified(firstComplement, second));
968
+ if (secondComplement !== -1)
969
+ return this.mkComplement(this.mkReXorSimplified(first, secondComplement));
970
+ if (manager.ids[first] > manager.ids[second]) return this.mkRe(OP_RE_XOR, [second, first]);
971
+ return undefined;
972
+ }
973
+
974
+ private mkReLoop(decl: number, args: number[]): Result {
975
+ const manager = this.manager;
976
+ const body = args[0];
977
+ if (args.length === 2) {
978
+ const lower = manager.getNumeral(args[1]);
979
+ if (lower !== undefined && lower >= 0n && lower <= BigInt(UINT_MAX))
980
+ return this.mkLoop(body, Number(lower));
981
+ if (lower !== undefined && lower < 0n) return this.mkEmptyOf(body);
982
+ return undefined;
983
+ }
984
+ if (args.length === 3) {
985
+ const lower = manager.getNumeral(args[1]);
986
+ const upper = manager.getNumeral(args[2]);
987
+ const isUnsigned = (value: bigint | undefined) =>
988
+ value !== undefined && value >= 0n && value <= BigInt(UINT_MAX);
989
+ return isUnsigned(lower) && isUnsigned(upper)
990
+ ? this.mkLoop(body, Number(lower), Number(upper))
991
+ : undefined;
992
+ }
993
+ if (args.length !== 1) return undefined;
994
+ const parameters = manager.funcDecls[decl].parameters;
995
+ const lo = parameters.length > 0 ? parameters[0] >>> 0 : 0;
996
+ const hi = parameters.length > 1 ? parameters[1] >>> 0 : lo;
997
+ if (parameters.length === 2 && lo > hi) return this.mkEmptyOf(body);
998
+ if (parameters.length === 2 && lo === 0 && hi === 0)
999
+ return this.mkToRe(mkEmptySeq(manager, this.getSeqSort(body)));
1000
+ if (parameters.length === 1 && lo === 0) return this.mkStar(body);
1001
+ if (parameters.length === 2 && lo === 1 && hi === 1) return body;
1002
+ const innerLower = getLoopLower(manager, body);
1003
+ if (
1004
+ innerLower !== undefined &&
1005
+ parameters.length === 1 &&
1006
+ (innerLower.lo === 0 || lo <= Math.floor(UINT_MAX / innerLower.lo))
1007
+ )
1008
+ return this.mkLoop(innerLower.body, lo * innerLower.lo);
1009
+ const inner = getLoopBounds(manager, body);
1010
+ if (
1011
+ inner !== undefined &&
1012
+ parameters.length === 2 &&
1013
+ inner.lo === inner.hi &&
1014
+ lo === hi &&
1015
+ (inner.lo === 0 || lo <= Math.floor(UINT_MAX / inner.lo))
1016
+ )
1017
+ return this.mkLoop(inner.body, lo * inner.lo, hi * inner.hi);
1018
+ return undefined;
1019
+ }
1020
+
1021
+ private mkReStar(regex: number): Result {
1022
+ const manager = this.manager;
1023
+ if (isReOp(manager, regex, OP_RE_STAR) || isFullSeq(manager, regex)) return regex;
1024
+ if (isFullChar(manager, regex)) return this.mkFullSeqOf(regex);
1025
+ if (isReEmpty(manager, regex)) return this.mkToRe(mkEmptySeq(manager, this.getSeqSort(regex)));
1026
+ if (isEpsilon(manager, regex)) return regex;
1027
+ const plus = this.getUnary(regex, OP_RE_PLUS);
1028
+ if (plus !== -1) return isFullChar(manager, plus) ? this.mkFullSeqOf(regex) : this.mkStar(plus);
1029
+ const union = this.getSplit(regex, OP_RE_UNION);
1030
+ if (union !== undefined) {
1031
+ const headStar = this.getUnary(union.head, OP_RE_STAR);
1032
+ if (headStar !== -1) return this.mkStar(this.mkUnion(headStar, union.tail));
1033
+ const tailStar = this.getUnary(union.tail, OP_RE_STAR);
1034
+ if (tailStar !== -1) return this.mkStar(this.mkUnion(union.head, tailStar));
1035
+ if (isEpsilon(manager, union.head)) return this.mkStar(union.tail);
1036
+ if (isEpsilon(manager, union.tail)) return this.mkStar(union.head);
1037
+ }
1038
+ const concat = this.getSplit(regex, OP_RE_CONCAT);
1039
+ if (concat !== undefined) {
1040
+ const headStar = this.getUnary(concat.head, OP_RE_STAR);
1041
+ const tailStar = this.getUnary(concat.tail, OP_RE_STAR);
1042
+ if (headStar !== -1 && tailStar !== -1) return this.mkStar(this.mkUnion(headStar, tailStar));
1043
+ if (isFullSeq(manager, concat.head))
1044
+ return this.mkUnion(mkEpsilon(manager, this.getSeqSort(regex)), regex);
1045
+ }
1046
+ const ite = this.getIte(regex);
1047
+ if (ite === undefined) return undefined;
1048
+ const isFullCharOrSeq = (expr: number) => isFullChar(manager, expr) || isFullSeq(manager, expr);
1049
+ if (isFullCharOrSeq(ite[1]) && isFullCharOrSeq(ite[2]))
1050
+ return rewrite(this.mkFullSeqOf(ite[1]), BR_REWRITE2);
1051
+ const thenStar = this.mkStar(ite[1]);
1052
+ const elseStar = this.mkStar(ite[2]);
1053
+ return this.mkBoolIte(ite[0], thenStar, elseStar);
1054
+ }
1055
+
1056
+ private getRangeBound(bound: number) {
1057
+ const manager = this.manager;
1058
+ const chars = manager.getString(bound);
1059
+ if (chars !== undefined && chars.length === 1) return chars[0];
1060
+ return manager.getOp(bound) === OP_SEQ_UNIT ? manager.getChar(manager.getArg(bound, 0)) : -1;
1061
+ }
1062
+
1063
+ private mkReRange(lo: number, hi: number): Result {
1064
+ const manager = this.manager;
1065
+ const isNeverChar = (bound: number) => {
1066
+ const maxLength = this.seq.getMaxLength(bound);
1067
+ return (
1068
+ this.seq.getMinLength([bound]).length > 1 ||
1069
+ (maxLength.isBounded && maxLength.length === 0n)
1070
+ );
1071
+ };
1072
+ const isLoEmpty = isNeverChar(lo);
1073
+ if (isLoEmpty || isNeverChar(hi))
1074
+ return mkReEmpty(manager, manager.mkReSort(manager.sorts[lo]));
1075
+ const loChar = this.getRangeBound(lo);
1076
+ const hiChar = this.getRangeBound(hi);
1077
+ if (loChar === -1 || hiChar === -1) return undefined;
1078
+ if (loChar > hiChar) return mkReEmpty(manager, manager.mkReSort(manager.sorts[lo]));
1079
+ if (loChar === hiChar) return this.mkRe(OP_SEQ_TO_RE, [manager.mkString([loChar])]);
1080
+ return undefined;
1081
+ }
1082
+
1083
+ private mkRePlus(regex: number): Result {
1084
+ const manager = this.manager;
1085
+ if (isFullChar(manager, regex)) return undefined;
1086
+ if (
1087
+ isReEmpty(manager, regex) ||
1088
+ isFullSeq(manager, regex) ||
1089
+ isEpsilon(manager, regex) ||
1090
+ isReOp(manager, regex, OP_RE_PLUS) ||
1091
+ isReOp(manager, regex, OP_RE_STAR)
1092
+ )
1093
+ return regex;
1094
+ return this.mkReAppend(regex, this.mkStar(regex));
1095
+ }
1096
+
1097
+ private mkReOpt(regex: number): Result {
1098
+ return this.mkUnion(this.mkToRe(mkEmptySeq(this.manager, this.getSeqSort(regex))), regex);
1099
+ }
1100
+
1101
+ private reduceReIsEmpty(regex: number): Result {
1102
+ const manager = this.manager;
1103
+ const union = this.getSplit(regex, OP_RE_UNION);
1104
+ if (union !== undefined) {
1105
+ const first = this.mkEqEmpty(union.head);
1106
+ const second = this.mkEqEmpty(union.tail);
1107
+ return rewrite(this.mkBool(OP_AND, [first, second]), BR_REWRITE2);
1108
+ }
1109
+ if (
1110
+ isReOp(manager, regex, OP_RE_STAR) ||
1111
+ isReOp(manager, regex, OP_SEQ_TO_RE) ||
1112
+ isFullChar(manager, regex) ||
1113
+ isFullSeq(manager, regex)
1114
+ )
1115
+ return manager.falseExpr;
1116
+ const concat = this.getSplit(regex, OP_RE_CONCAT);
1117
+ if (concat !== undefined) {
1118
+ const first = this.mkEqEmpty(concat.head);
1119
+ const second = this.mkEqEmpty(concat.tail);
1120
+ return rewrite(this.mkBool(OP_OR, [first, second]), BR_REWRITE2);
1121
+ }
1122
+ const range = this.getSplit(regex, OP_RE_RANGE);
1123
+ if (range !== undefined) {
1124
+ const loChars = manager.getString(range.head);
1125
+ const hiChars = manager.getString(range.tail);
1126
+ if (loChars?.length === 1 && hiChars?.length === 1)
1127
+ return loChars[0] > hiChars[0] ? manager.trueExpr : manager.falseExpr;
1128
+ if (loChars !== undefined && loChars.length !== 1) return manager.trueExpr;
1129
+ if (hiChars !== undefined && hiChars.length !== 1) return manager.trueExpr;
1130
+ }
1131
+ const loop = getLoopLower(manager, regex) ?? getLoopBounds(manager, regex);
1132
+ if (loop !== undefined && loop.lo === 0) return manager.falseExpr;
1133
+ if (loop !== undefined && loop.lo <= loop.hi)
1134
+ return rewrite(this.mkEqEmpty(loop.body), BR_REWRITE1);
1135
+ const inter = this.getSplit(regex, OP_RE_INTERSECT);
1136
+ if (inter === undefined) return undefined;
1137
+ for (const [union, other] of [
1138
+ [inter.head, inter.tail],
1139
+ [inter.tail, inter.head],
1140
+ ]) {
1141
+ const split = this.getSplit(union, OP_RE_UNION);
1142
+ if (split === undefined) continue;
1143
+ const first = this.mkRe(OP_RE_INTERSECT, [split.head, other]);
1144
+ const second = this.mkRe(OP_RE_INTERSECT, [split.tail, other]);
1145
+ return rewrite(this.mkEqEmpty(this.mkRe(OP_RE_UNION, [first, second])), BR_REWRITE3);
1146
+ }
1147
+ return undefined;
1148
+ }
1149
+
1150
+ reduceReEq(inputLeft: number, inputRight: number): Result {
1151
+ const manager = this.manager;
1152
+ const isSwapped = isReEmpty(manager, inputLeft);
1153
+ const left = isSwapped ? inputRight : inputLeft;
1154
+ const right = isSwapped ? inputLeft : inputRight;
1155
+ if (isReEmpty(manager, right)) return this.reduceReIsEmpty(left);
1156
+ if (left === right) return manager.trueExpr;
1157
+ if (this.isInBisim || !isReGround(this.info, left) || !isReGround(this.info, right))
1158
+ return undefined;
1159
+ this.isInBisim = true;
1160
+ const bisim = new RegexBisim(manager, this);
1161
+ const status = bisim.areEquivalent(left, right);
1162
+ bisim.release();
1163
+ this.isInBisim = false;
1164
+ return status === L_TRUE
1165
+ ? manager.trueExpr
1166
+ : status === L_FALSE
1167
+ ? manager.falseExpr
1168
+ : undefined;
1169
+ }
1170
+ }