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,1301 @@
1
+ import { mkArrayApp } from "./array-decl-plugin";
2
+ import {
3
+ type AstManager,
4
+ KIND_APP,
5
+ OP_AND,
6
+ OP_CHAR_LE,
7
+ OP_EQ,
8
+ OP_GE,
9
+ OP_ITE,
10
+ OP_NOT,
11
+ OP_OR,
12
+ OP_RE_COMPLEMENT,
13
+ OP_RE_CONCAT,
14
+ OP_RE_DERIVATIVE,
15
+ OP_RE_DIFF,
16
+ OP_RE_INTERSECT,
17
+ OP_RE_LOOP,
18
+ OP_RE_OF_PRED,
19
+ OP_RE_OPTION,
20
+ OP_RE_PLUS,
21
+ OP_RE_RANGE,
22
+ OP_RE_REVERSE,
23
+ OP_RE_STAR,
24
+ OP_RE_UNION,
25
+ OP_RE_XOR,
26
+ OP_SELECT,
27
+ OP_SEQ_CONCAT,
28
+ OP_SEQ_EXTRACT,
29
+ OP_SEQ_IN_RE,
30
+ OP_SEQ_LENGTH,
31
+ OP_SEQ_NTH_I,
32
+ OP_SEQ_TO_RE,
33
+ OP_SEQ_UNIT,
34
+ OP_STRING_ITOS,
35
+ OP_SUB,
36
+ SORT_BOOL,
37
+ SORT_INT,
38
+ } from "./ast";
39
+ import { assign } from "./expr-ref";
40
+ import { ExprSafeReplace } from "./expr-safe-replace";
41
+ import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
42
+ import { RefVector } from "./ref-vector";
43
+ import { KERNEL_REWRITER_OPTIONS, Rewriter } from "./rewriter";
44
+ import { isEmptySeq, mkEmptySeq, mkSeqApp } from "./seq-decl-plugin";
45
+ import {
46
+ getCharConstRange,
47
+ getLoopBounds,
48
+ getLoopLower,
49
+ ReInfoCache,
50
+ getUnitStringChar,
51
+ isDotPlus,
52
+ isEpsilon,
53
+ isFullChar,
54
+ isFullSeq,
55
+ isReBinary,
56
+ isReEmpty,
57
+ isReOp,
58
+ isReUnary,
59
+ mkCharLe,
60
+ mkFullSeq,
61
+ mkReEmpty,
62
+ } from "./seq-re-util";
63
+ import { type ReRewriter, getResultExpr } from "./seq-re-rewriter";
64
+
65
+ export const DERIVATIVE_ANTIMIROV = 0;
66
+ export const DERIVATIVE_BRZOZOWSKI = 1;
67
+ export const TRANSITION_BRZOZOWSKI = 0;
68
+ export const TRANSITION_LIGHT_ANTIMIROV = 1;
69
+
70
+ const MAX_DEPTH = 512;
71
+ const MAX_TRAIL_SIZE = 500000;
72
+ const MAX_OP_TRAIL_SIZE = 100000;
73
+
74
+ type PairMap = Map<number, Map<number, number>>;
75
+ type TripleMap = Map<number, PairMap>;
76
+
77
+ const getPair = (map: PairMap, first: number, second: number) => map.get(first)?.get(second);
78
+
79
+ const setPair = (map: PairMap, first: number, second: number, value: number) => {
80
+ const inner = map.get(first);
81
+ if (inner === undefined) map.set(first, new Map([[second, value]]));
82
+ else inner.set(second, value);
83
+ };
84
+
85
+ const getTriple = (map: TripleMap, first: number, second: number, third: number) =>
86
+ map.get(first)?.get(second)?.get(third);
87
+
88
+ const setTriple = (map: TripleMap, first: number, second: number, third: number, value: number) => {
89
+ const inner = map.get(first);
90
+ if (inner === undefined) map.set(first, new Map([[second, new Map([[third, value]])]]));
91
+ else setPair(inner, second, third, value);
92
+ };
93
+
94
+ const mkPairMaps = (): PairMap[] => [new Map(), new Map()];
95
+ const mkTripleMaps = (): TripleMap[] => [new Map(), new Map()];
96
+
97
+ interface Decomposed {
98
+ condition: number;
99
+ thenExpr: number;
100
+ elseExpr: number;
101
+ }
102
+
103
+ class CofactorCache {
104
+ readonly cofactors = new Map<number, RefVector>();
105
+ private pins: RefVector;
106
+
107
+ constructor(manager: AstManager) {
108
+ this.pins = new RefVector(manager);
109
+ }
110
+
111
+ insert(regex: number, cofactors: RefVector) {
112
+ this.pins.push(regex);
113
+ this.cofactors.set(regex, cofactors);
114
+ }
115
+
116
+ reset() {
117
+ for (const cofactors of this.cofactors.values()) cofactors.reset();
118
+ this.cofactors.clear();
119
+ this.pins.reset();
120
+ }
121
+
122
+ maybeReset(cap: number) {
123
+ if (this.cofactors.size > cap) this.reset();
124
+ }
125
+ }
126
+
127
+ export class Derive {
128
+ private bool: Rewriter;
129
+ private info: ReInfoCache;
130
+ private caches = mkPairMaps();
131
+ private topCaches = mkPairMaps();
132
+ private unionCaches = mkTripleMaps();
133
+ private interCaches = mkTripleMaps();
134
+ private xorCaches = mkTripleMaps();
135
+ private concatCaches = mkPairMaps();
136
+ private complementCaches = mkPairMaps();
137
+ private trail: RefVector;
138
+ private brzCofactorCache: CofactorCache;
139
+ private antCofactorCache: CofactorCache;
140
+ private firstReplace: ExprSafeReplace;
141
+ private secondReplace: ExprSafeReplace;
142
+ private depth = 0;
143
+ private kind = DERIVATIVE_ANTIMIROV;
144
+ private element = -1;
145
+ private pathConds: number[] = [];
146
+ private pathSigns: boolean[] = [];
147
+ private intervals: number[] = [];
148
+ private intervalsStart = 0;
149
+ private pathStack: number[] = [];
150
+ private pathExpr = -1;
151
+
152
+ constructor(
153
+ private manager: AstManager,
154
+ private re: ReRewriter,
155
+ ) {
156
+ this.bool = new Rewriter(manager, { ...KERNEL_REWRITER_OPTIONS, isFlatAndOr: false });
157
+ this.info = new ReInfoCache(manager);
158
+ this.trail = new RefVector(manager);
159
+ this.brzCofactorCache = new CofactorCache(manager);
160
+ this.antCofactorCache = new CofactorCache(manager);
161
+ this.firstReplace = new ExprSafeReplace(manager);
162
+ this.secondReplace = new ExprSafeReplace(manager);
163
+ }
164
+
165
+ release() {
166
+ this.pathExpr = assign(this.manager, this.pathExpr, -1);
167
+ this.element = assign(this.manager, this.element, -1);
168
+ this.antCofactorCache.reset();
169
+ this.brzCofactorCache.reset();
170
+ this.trail.reset();
171
+ this.secondReplace.release();
172
+ this.firstReplace.release();
173
+ this.bool.release();
174
+ this.info.release();
175
+ }
176
+
177
+ private reset() {
178
+ // Deviation from Z3: the xor caches go too, as the trail was all that kept their results alive.
179
+ for (const cache of [...this.caches, ...this.topCaches, ...this.xorCaches]) cache.clear();
180
+ this.resetOpCaches();
181
+ this.trail.reset();
182
+ this.element = assign(this.manager, this.element, -1);
183
+ }
184
+
185
+ private resetOpCaches() {
186
+ for (const cache of [
187
+ this.unionCaches[DERIVATIVE_ANTIMIROV],
188
+ this.interCaches[DERIVATIVE_ANTIMIROV],
189
+ this.concatCaches[DERIVATIVE_ANTIMIROV],
190
+ this.complementCaches[DERIVATIVE_ANTIMIROV],
191
+ this.unionCaches[DERIVATIVE_BRZOZOWSKI],
192
+ this.interCaches[DERIVATIVE_BRZOZOWSKI],
193
+ this.concatCaches[DERIVATIVE_BRZOZOWSKI],
194
+ this.complementCaches[DERIVATIVE_BRZOZOWSKI],
195
+ ])
196
+ cache.clear();
197
+ this.element = assign(this.manager, this.element, -1);
198
+ }
199
+
200
+ private resetPath() {
201
+ this.pathConds.length = 0;
202
+ this.pathSigns.length = 0;
203
+ this.intervals = [0, this.manager.maxChar];
204
+ this.intervalsStart = 0;
205
+ this.pathExpr = assign(this.manager, this.pathExpr, this.manager.trueExpr);
206
+ }
207
+
208
+ derive(kind: number, element: number, regex: number) {
209
+ const manager = this.manager;
210
+ this.kind = kind;
211
+ if (this.trail.size > MAX_TRAIL_SIZE) this.reset();
212
+ else if (this.trail.size > MAX_OP_TRAIL_SIZE || element !== this.element) this.resetOpCaches();
213
+ const cached = getPair(this.topCaches[kind], element, regex);
214
+ if (cached !== undefined) return cached;
215
+ this.trail.push(element);
216
+ this.trail.push(regex);
217
+ this.element = assign(manager, this.element, element);
218
+ this.depth = 0;
219
+ this.resetPath();
220
+ const result = this.deriveRec(regex);
221
+ setPair(this.topCaches[kind], element, regex, result);
222
+ this.trail.push(result);
223
+ return result;
224
+ }
225
+
226
+ deriveSymbolic(kind: number, regex: number) {
227
+ const manager = this.manager;
228
+ const elementSort = manager.getSeqElementSort(manager.getReSeqSort(manager.sorts[regex]));
229
+ return this.derive(kind, manager.mkVar(0, elementSort), regex);
230
+ }
231
+
232
+ isNullable(regex: number): number {
233
+ const manager = this.manager;
234
+ const bool = this.bool;
235
+ const isRe = manager.isReSort(manager.sorts[regex]);
236
+ if (isRe) {
237
+ const nullable = this.info.getInfo(regex).nullable;
238
+ if (nullable === L_TRUE) return manager.trueExpr;
239
+ if (nullable === L_FALSE) return manager.falseExpr;
240
+ }
241
+ const first =
242
+ manager.kinds[regex] === KIND_APP && manager.getNumArgs(regex) > 0
243
+ ? manager.getArg(regex, 0)
244
+ : -1;
245
+ const second =
246
+ manager.kinds[regex] === KIND_APP && manager.getNumArgs(regex) > 1
247
+ ? manager.getArg(regex, 1)
248
+ : -1;
249
+ if (isReBinary(manager, regex, OP_RE_CONCAT) || isReBinary(manager, regex, OP_RE_INTERSECT)) {
250
+ const firstNullable = this.isNullable(first);
251
+ return bool.mkAnd([firstNullable, this.isNullable(second)]);
252
+ }
253
+ if (isReBinary(manager, regex, OP_RE_UNION)) {
254
+ const firstNullable = this.isNullable(first);
255
+ return bool.mkOr([firstNullable, this.isNullable(second)]);
256
+ }
257
+ if (isReBinary(manager, regex, OP_RE_DIFF)) {
258
+ const negated = bool.mkNot(this.isNullable(second));
259
+ return bool.mkAnd([negated, this.isNullable(first)]);
260
+ }
261
+ if (isReBinary(manager, regex, OP_RE_XOR)) {
262
+ const firstNullable = this.isNullable(first);
263
+ const secondNullable = this.isNullable(second);
264
+ return bool.mkEq(bool.mkNot(firstNullable), secondNullable);
265
+ }
266
+ const loop = getLoopLower(manager, regex) ?? getLoopBounds(manager, regex);
267
+ if (
268
+ isReOp(manager, regex, OP_RE_STAR) ||
269
+ isReOp(manager, regex, OP_RE_OPTION) ||
270
+ isFullSeq(manager, regex) ||
271
+ isEpsilon(manager, regex) ||
272
+ loop?.lo === 0
273
+ )
274
+ return manager.trueExpr;
275
+ if (
276
+ isFullChar(manager, regex) ||
277
+ isReEmpty(manager, regex) ||
278
+ isReOp(manager, regex, OP_RE_OF_PRED) ||
279
+ isReOp(manager, regex, OP_RE_RANGE)
280
+ )
281
+ return manager.falseExpr;
282
+ if (
283
+ isReUnary(manager, regex, OP_RE_PLUS) ||
284
+ loop !== undefined ||
285
+ isReUnary(manager, regex, OP_RE_REVERSE)
286
+ )
287
+ return this.isNullable(first);
288
+ if (isReUnary(manager, regex, OP_RE_COMPLEMENT)) return bool.mkNot(this.isNullable(first));
289
+ if (isReUnary(manager, regex, OP_SEQ_TO_RE)) return this.isNullable(first);
290
+ if (manager.getOp(regex) === OP_ITE) {
291
+ const thenNullable = this.isNullable(second);
292
+ const elseNullable = this.isNullable(manager.getArg(regex, 2));
293
+ return getResultExpr(bool.mkIte(first, thenNullable, elseNullable));
294
+ }
295
+ if (isRe)
296
+ return this.isNullableSymbolicRegex(regex, manager.getReSeqSort(manager.sorts[regex]));
297
+ if (isReBinary(manager, regex, OP_SEQ_CONCAT)) {
298
+ const firstNullable = this.isNullable(first);
299
+ return bool.mkAnd([firstNullable, this.isNullable(second)]);
300
+ }
301
+ if (isEmptySeq(manager, regex)) return manager.trueExpr;
302
+ if (manager.getOp(regex) === OP_SEQ_UNIT) return manager.falseExpr;
303
+ if (manager.getString(regex) !== undefined) return manager.falseExpr;
304
+ return manager.mkEq(mkEmptySeq(manager, manager.sorts[regex]), regex);
305
+ }
306
+
307
+ private isNullableSymbolicRegex(regex: number, seqSort: number) {
308
+ const manager = this.manager;
309
+ let elements = mkEmptySeq(manager, seqSort);
310
+ let current = regex;
311
+ while (isReBinary(manager, current, OP_RE_DERIVATIVE)) {
312
+ const unit = mkSeqApp(manager, OP_SEQ_UNIT, [manager.getArg(current, 0)]);
313
+ elements = isEmptySeq(manager, elements)
314
+ ? unit
315
+ : mkSeqApp(manager, OP_SEQ_CONCAT, [unit, elements]);
316
+ current = manager.getArg(current, 1);
317
+ }
318
+ if (isReUnary(manager, current, OP_SEQ_TO_RE))
319
+ return manager.mkEq(elements, manager.getArg(current, 0));
320
+ return mkSeqApp(manager, OP_SEQ_IN_RE, [mkEmptySeq(manager, seqSort), regex]);
321
+ }
322
+
323
+ private deriveRec(regex: number): number {
324
+ const cached = getPair(this.caches[this.kind], this.element, regex);
325
+ if (cached !== undefined) return cached;
326
+ if (this.depth >= MAX_DEPTH) return this.mkStuckDerivative(regex);
327
+ this.depth++;
328
+ const result = this.deriveCore(regex);
329
+ this.depth--;
330
+ setPair(this.caches[this.kind], this.element, regex, result);
331
+ this.trail.push(this.element);
332
+ this.trail.push(regex);
333
+ this.trail.push(result);
334
+ return result;
335
+ }
336
+
337
+ private mkStuckDerivative(regex: number) {
338
+ return mkSeqApp(this.manager, OP_RE_DERIVATIVE, [this.element, regex]);
339
+ }
340
+
341
+ private deriveCore(regex: number): number {
342
+ const manager = this.manager;
343
+ const re = this.re;
344
+ const sort = manager.sorts[regex];
345
+ const seqSort = manager.getReSeqSort(sort);
346
+ const nothing = () => mkReEmpty(manager, sort);
347
+ if (isReEmpty(manager, regex) || isEpsilon(manager, regex)) return nothing();
348
+ if (isFullSeq(manager, regex) || isDotPlus(manager, regex)) return mkFullSeq(manager, sort);
349
+ if (isFullChar(manager, regex)) return re.mkToRe(mkEmptySeq(manager, seqSort));
350
+ const numArgs = manager.kinds[regex] === KIND_APP ? manager.getNumArgs(regex) : 0;
351
+ const first = numArgs > 0 ? manager.getArg(regex, 0) : -1;
352
+ const second = numArgs > 1 ? manager.getArg(regex, 1) : -1;
353
+ if (isReUnary(manager, regex, OP_SEQ_TO_RE)) return this.deriveToRe(first, seqSort);
354
+ if (isReBinary(manager, regex, OP_RE_RANGE)) return this.deriveRange(first, second, seqSort);
355
+ if (isReUnary(manager, regex, OP_RE_OF_PRED)) return this.deriveOfPred(first, seqSort);
356
+ if (isReBinary(manager, regex, OP_RE_CONCAT)) {
357
+ if (isReOp(manager, first, OP_RE_CONCAT)) {
358
+ const normalized = this.mkConcat(first, second);
359
+ if (normalized !== regex) return this.deriveRec(normalized);
360
+ }
361
+ const firstDerivative = this.deriveRec(first);
362
+ const concat = this.mkDerivConcat(firstDerivative, second);
363
+ const nullable = this.isNullable(first);
364
+ if (manager.isTrue(nullable)) return this.mkUnion(concat, this.deriveRec(second));
365
+ if (manager.isFalse(nullable)) return concat;
366
+ const secondDerivative = this.deriveRec(second);
367
+ const guarded = this.mkIte(nullable, secondDerivative, nothing());
368
+ return this.mkUnion(concat, guarded);
369
+ }
370
+ for (const op of [OP_RE_UNION, OP_RE_XOR, OP_RE_INTERSECT]) {
371
+ if (!isReBinary(manager, regex, op)) continue;
372
+ const firstDerivative = this.deriveRec(first);
373
+ const secondDerivative = this.deriveRec(second);
374
+ return op === OP_RE_UNION
375
+ ? this.mkUnion(firstDerivative, secondDerivative)
376
+ : op === OP_RE_XOR
377
+ ? this.mkXor(firstDerivative, secondDerivative)
378
+ : this.mkInter(firstDerivative, secondDerivative);
379
+ }
380
+ for (const op of [OP_RE_UNION, OP_RE_INTERSECT, OP_RE_CONCAT, OP_RE_XOR])
381
+ if (isReUnary(manager, regex, op)) return this.deriveRec(first);
382
+ if (isReUnary(manager, regex, OP_RE_COMPLEMENT))
383
+ return this.mkComplement(this.deriveRec(first));
384
+ if (isReUnary(manager, regex, OP_RE_STAR) || isReUnary(manager, regex, OP_RE_PLUS)) {
385
+ const firstDerivative = this.deriveRec(first);
386
+ return this.mkDerivConcat(firstDerivative, re.mkStar(first));
387
+ }
388
+ if (isReUnary(manager, regex, OP_RE_OPTION)) return this.deriveRec(first);
389
+ const bounds = getLoopBounds(manager, regex);
390
+ if (bounds !== undefined) {
391
+ if (bounds.hi === 0 || bounds.hi < bounds.lo) return nothing();
392
+ const firstDerivative = this.deriveRec(bounds.body);
393
+ const tail = re.mkLoop(bounds.body, bounds.lo === 0 ? 0 : bounds.lo - 1, bounds.hi - 1);
394
+ return this.mkDerivConcat(firstDerivative, tail);
395
+ }
396
+ const lower = getLoopLower(manager, regex);
397
+ if (lower !== undefined) {
398
+ const firstDerivative = this.deriveRec(lower.body);
399
+ const tail = re.mkLoop(lower.body, lower.lo === 0 ? 0 : lower.lo - 1);
400
+ return this.mkDerivConcat(firstDerivative, tail);
401
+ }
402
+ if (isReOp(manager, regex, OP_RE_LOOP)) {
403
+ const getUnsigned = (expr: number) => {
404
+ const value = manager.getNumeral(expr);
405
+ return value !== undefined && value >= 0n && value <= 0xffffffffn ? Number(value) : -1;
406
+ };
407
+ if (
408
+ numArgs === 3 &&
409
+ getUnsigned(second) !== -1 &&
410
+ getUnsigned(manager.getArg(regex, 2)) !== -1
411
+ )
412
+ return this.deriveRec(
413
+ re.mkLoop(first, getUnsigned(second), getUnsigned(manager.getArg(regex, 2))),
414
+ );
415
+ if (numArgs === 2 && getUnsigned(second) !== -1)
416
+ return this.deriveRec(re.mkLoop(first, getUnsigned(second)));
417
+ }
418
+ if (isReBinary(manager, regex, OP_RE_DIFF)) {
419
+ const firstDerivative = this.deriveRec(first);
420
+ const secondDerivative = this.deriveRec(second);
421
+ return this.mkInter(firstDerivative, this.mkComplement(secondDerivative));
422
+ }
423
+ if (manager.getOp(regex) === OP_ITE) {
424
+ const thenDerivative = this.deriveRec(second);
425
+ const elseDerivative = this.deriveRec(manager.getArg(regex, 2));
426
+ return this.mkIte(first, thenDerivative, elseDerivative);
427
+ }
428
+ if (isReUnary(manager, regex, OP_RE_REVERSE)) {
429
+ const normalized = re.mkReverse(first);
430
+ if (normalized !== regex) return this.deriveRec(normalized);
431
+ }
432
+ return this.mkStuckDerivative(regex);
433
+ }
434
+
435
+ private mkEqElement(expr: number) {
436
+ return this.manager.mkEq(this.element, expr);
437
+ }
438
+
439
+ private mkRestAfterFirst(seq: number) {
440
+ const manager = this.manager;
441
+ const one = manager.mkNumeral(1n);
442
+ const length = mkSeqApp(manager, OP_SEQ_LENGTH, [seq]);
443
+ const restLength = manager.mkApp(OP_SUB, [length, one], SORT_INT);
444
+ return mkSeqApp(manager, OP_SEQ_EXTRACT, [seq, one, restLength]);
445
+ }
446
+
447
+ private deriveToRe(seq: number, seqSort: number) {
448
+ const manager = this.manager;
449
+ const re = this.re;
450
+ const reSort = manager.mkReSort(seqSort);
451
+ if (isEmptySeq(manager, seq)) return mkReEmpty(manager, reSort);
452
+ const chars = manager.getString(seq);
453
+ if (chars !== undefined) {
454
+ const condition = this.mkEqElement(manager.mkChar(chars[0]));
455
+ const tail = re.mkToRe(manager.mkString(chars.slice(1)));
456
+ return this.mkIte(condition, tail, mkReEmpty(manager, reSort));
457
+ }
458
+ if (manager.getOp(seq) === OP_SEQ_UNIT) {
459
+ const epsilon = re.mkToRe(mkEmptySeq(manager, seqSort));
460
+ const empty = mkReEmpty(manager, reSort);
461
+ return this.mkIte(this.mkEqElement(manager.getArg(seq, 0)), epsilon, empty);
462
+ }
463
+ if (isReBinary(manager, seq, OP_SEQ_CONCAT)) {
464
+ const split = this.getHeadTail(manager.getArg(seq, 0), manager.getArg(seq, 1));
465
+ if (split !== undefined) {
466
+ const condition = this.mkEqElement(split[0]);
467
+ const tail = re.mkToRe(split[1]);
468
+ return this.mkIte(condition, tail, mkReEmpty(manager, reSort));
469
+ }
470
+ }
471
+ if (manager.getOp(seq) === OP_STRING_ITOS) {
472
+ const empty = mkReEmpty(manager, reSort);
473
+ const isNonNegative = manager.mkApp(
474
+ OP_GE,
475
+ [manager.getArg(seq, 0), manager.mkNumeral(0n)],
476
+ SORT_BOOL,
477
+ );
478
+ const zeroChar = manager.mkChar(48);
479
+ const nineChar = manager.mkChar(57);
480
+ const isAboveZero = mkCharLe(manager, zeroChar, this.element);
481
+ const isBelowNine = mkCharLe(manager, this.element, nineChar);
482
+ const isDigit = manager.mkApp(OP_AND, [isAboveZero, isBelowNine], SORT_BOOL);
483
+ const zero = manager.mkNumeral(0n);
484
+ const isFirst = this.mkEqElement(mkSeqApp(manager, OP_SEQ_NTH_I, [seq, zero]));
485
+ const guard = manager.mkApp(
486
+ OP_AND,
487
+ [isNonNegative, manager.mkApp(OP_AND, [isDigit, isFirst], SORT_BOOL)],
488
+ SORT_BOOL,
489
+ );
490
+ return this.mkIte(guard, re.mkToRe(this.mkRestAfterFirst(seq)), empty);
491
+ }
492
+ const isNonEmpty = manager.mkApp(
493
+ OP_NOT,
494
+ [manager.mkEq(seq, mkEmptySeq(manager, seqSort))],
495
+ SORT_BOOL,
496
+ );
497
+ const zero = manager.mkNumeral(0n);
498
+ const isFirst = this.mkEqElement(mkSeqApp(manager, OP_SEQ_NTH_I, [seq, zero]));
499
+ const guard = manager.mkApp(OP_AND, [isNonEmpty, isFirst], SORT_BOOL);
500
+ const rest = re.mkToRe(this.mkRestAfterFirst(seq));
501
+ return this.mkIte(guard, rest, mkReEmpty(manager, reSort));
502
+ }
503
+
504
+ private deriveRange(lo: number, hi: number, seqSort: number) {
505
+ const manager = this.manager;
506
+ const reSort = manager.mkReSort(seqSort);
507
+ const empty = mkReEmpty(manager, reSort);
508
+ const epsilon = this.re.mkToRe(mkEmptySeq(manager, seqSort));
509
+ const loUnit = getUnitStringChar(manager, lo);
510
+ const hiUnit = loUnit === -1 ? -1 : getUnitStringChar(manager, hi);
511
+ if (loUnit !== -1 && hiUnit !== -1) {
512
+ const isLoTrivial = manager.getChar(loUnit) === 0;
513
+ const isHiTrivial = manager.getChar(hiUnit) === this.manager.maxChar;
514
+ if (isLoTrivial && isHiTrivial) return epsilon;
515
+ const isInRange = isLoTrivial
516
+ ? mkCharLe(manager, this.element, hiUnit)
517
+ : isHiTrivial
518
+ ? mkCharLe(manager, loUnit, this.element)
519
+ : manager.mkApp(
520
+ OP_AND,
521
+ [mkCharLe(manager, loUnit, this.element), mkCharLe(manager, this.element, hiUnit)],
522
+ SORT_BOOL,
523
+ );
524
+ return this.mkIte(isInRange, epsilon, empty);
525
+ }
526
+ const conds: number[] = [];
527
+ const zero = manager.mkNumeral(0n);
528
+ const getBound = (bound: number) => {
529
+ const unit = getUnitStringChar(manager, bound);
530
+ if (unit !== -1) return unit;
531
+ const length = mkSeqApp(manager, OP_SEQ_LENGTH, [bound]);
532
+ conds.push(manager.mkEq(length, manager.mkNumeral(1n)));
533
+ return mkSeqApp(manager, OP_SEQ_NTH_I, [bound, zero]);
534
+ };
535
+ const loChar = getBound(lo);
536
+ const hiChar = getBound(hi);
537
+ conds.push(mkCharLe(manager, loChar, this.element));
538
+ conds.push(mkCharLe(manager, this.element, hiChar));
539
+ return this.mkIte(this.bool.mkAnd(conds), epsilon, empty);
540
+ }
541
+
542
+ private deriveOfPred(predicate: number, seqSort: number) {
543
+ const manager = this.manager;
544
+ const empty = mkReEmpty(manager, manager.mkReSort(seqSort));
545
+ const epsilon = this.re.mkToRe(mkEmptySeq(manager, seqSort));
546
+ const condition = mkArrayApp(manager, OP_SELECT, [predicate, this.element]);
547
+ return this.mkIte(condition, epsilon, empty);
548
+ }
549
+
550
+ private getHeadTail(first: number, second: number): [number, number] | undefined {
551
+ const manager = this.manager;
552
+ if (manager.getOp(first) === OP_SEQ_UNIT) return [manager.getArg(first, 0), second];
553
+ if (isReBinary(manager, first, OP_SEQ_CONCAT)) {
554
+ const tail = this.re.mkSeqConcat(manager.getArg(first, 1), second);
555
+ return this.getHeadTail(manager.getArg(first, 0), tail);
556
+ }
557
+ const chars = manager.getString(first);
558
+ if (chars === undefined || chars.length === 0) return undefined;
559
+ const head = manager.mkChar(chars[0]);
560
+ return [
561
+ head,
562
+ chars.length === 1 ? second : this.re.mkSeqConcat(manager.mkString(chars.slice(1)), second),
563
+ ];
564
+ }
565
+
566
+ private isPredImplying(
567
+ isFirstNegated: boolean,
568
+ first: number,
569
+ isSecondNegated: boolean,
570
+ second: number,
571
+ ): boolean {
572
+ if (first === second) return isFirstNegated === isSecondNegated;
573
+ if (isFirstNegated && isSecondNegated) return this.isPredImplying(false, second, false, first);
574
+ const manager = this.manager;
575
+ const firstRange = getCharConstRange(manager, this.element, first);
576
+ const secondRange =
577
+ firstRange === undefined || firstRange.isNegated
578
+ ? undefined
579
+ : getCharConstRange(manager, this.element, second);
580
+ if (firstRange === undefined || secondRange === undefined || secondRange.isNegated)
581
+ return false;
582
+ if (!isFirstNegated && !isSecondNegated)
583
+ return secondRange.lo <= firstRange.lo && firstRange.hi <= secondRange.hi;
584
+ if (!isFirstNegated) return firstRange.hi < secondRange.lo || secondRange.hi < firstRange.lo;
585
+ return secondRange.lo === 0 && secondRange.hi >= this.manager.maxChar;
586
+ }
587
+
588
+ private mkXor(first: number, second: number): number {
589
+ return this.mkCore(OP_RE_XOR, first, second);
590
+ }
591
+
592
+ private mkCore(op: number, first: number, second: number): number {
593
+ const pathExpr = this.pathExpr;
594
+ const cache =
595
+ op === OP_RE_UNION
596
+ ? this.unionCaches[this.kind]
597
+ : op === OP_RE_INTERSECT
598
+ ? this.interCaches[this.kind]
599
+ : this.xorCaches[this.kind];
600
+ const cached = getTriple(cache, first, second, pathExpr);
601
+ if (cached !== undefined) return cached;
602
+ const apply = (left: number, right: number) =>
603
+ op === OP_RE_UNION
604
+ ? this.mkUnion(left, right)
605
+ : op === OP_RE_INTERSECT
606
+ ? this.mkInter(left, right)
607
+ : this.mkXor(left, right);
608
+ const hoisted =
609
+ op !== OP_RE_UNION || this.kind === DERIVATIVE_BRZOZOWSKI
610
+ ? this.hoistIte(first, second, apply)
611
+ : -1;
612
+ const result =
613
+ hoisted !== -1
614
+ ? hoisted
615
+ : op === OP_RE_UNION
616
+ ? this.mkUnionCore(first, second)
617
+ : op === OP_RE_INTERSECT
618
+ ? this.mkInterCore(first, second)
619
+ : this.re.mkXor0(first, second);
620
+ setTriple(cache, first, second, pathExpr, result);
621
+ this.trail.push(first);
622
+ this.trail.push(second);
623
+ this.trail.push(pathExpr);
624
+ this.trail.push(result);
625
+ return result;
626
+ }
627
+
628
+ private mkUnion(first: number, second: number): number {
629
+ return this.mkCore(OP_RE_UNION, first, second);
630
+ }
631
+
632
+ private mkUnionCore(first: number, second: number) {
633
+ const manager = this.manager;
634
+ const sort = manager.sorts[first];
635
+ if (isReEmpty(manager, first)) return second;
636
+ if (isReEmpty(manager, second)) return first;
637
+ if (first === second) return first;
638
+ if (isFullSeq(manager, first) || isFullSeq(manager, second)) return mkFullSeq(manager, sort);
639
+ const elements: number[] = [];
640
+ const todo = [second, first];
641
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
642
+ if (isReBinary(manager, expr, OP_RE_UNION)) {
643
+ todo.push(manager.getArg(expr, 1), manager.getArg(expr, 0));
644
+ continue;
645
+ }
646
+ if (isReEmpty(manager, expr)) continue;
647
+ if (isFullSeq(manager, expr)) return mkFullSeq(manager, sort);
648
+ this.addUnionElement(elements, expr);
649
+ }
650
+ if (elements.length === 0) return mkReEmpty(manager, sort);
651
+ let result = elements[0];
652
+ for (let index = 1; index < elements.length; index++)
653
+ result = this.re.mkUnion(result, elements[index]);
654
+ return result;
655
+ }
656
+
657
+ private addUnionElement(elements: number[], input: number) {
658
+ const manager = this.manager;
659
+ let element = input;
660
+ let isChanged = true;
661
+ while (isChanged) {
662
+ isChanged = false;
663
+ for (let index = 0; index < elements.length; index++) {
664
+ const other = elements[index];
665
+ if (other === element || this.re.isSubset(element, other)) return;
666
+ if (this.re.isSubset(other, element)) {
667
+ elements[index] = elements[elements.length - 1];
668
+ elements.pop();
669
+ isChanged = true;
670
+ break;
671
+ }
672
+ if (
673
+ manager.getOp(element) === OP_ITE &&
674
+ manager.getOp(other) === OP_ITE &&
675
+ manager.getArg(element, 0) === manager.getArg(other, 0)
676
+ ) {
677
+ const [condition, firstThen, firstElse] = manager.getArgs(element);
678
+ const secondThen = manager.getArg(other, 1);
679
+ const secondElse = manager.getArg(other, 2);
680
+ elements[index] = elements[elements.length - 1];
681
+ elements.pop();
682
+ const thenUnion = this.mkUnion(firstThen, secondThen);
683
+ const elseUnion = this.mkUnion(firstElse, secondElse);
684
+ element = this.mkIte(condition, thenUnion, elseUnion);
685
+ isChanged = true;
686
+ break;
687
+ }
688
+ }
689
+ }
690
+ elements.push(element);
691
+ }
692
+
693
+ private mkInter(first: number, second: number): number {
694
+ return this.mkCore(OP_RE_INTERSECT, first, second);
695
+ }
696
+
697
+ private mkInterCore(first: number, second: number): number {
698
+ const manager = this.manager;
699
+ if (this.re.isSubset(first, second)) return first;
700
+ if (this.re.isSubset(second, first)) return second;
701
+ if (this.re.areComplements(first, second)) return mkReEmpty(manager, manager.sorts[first]);
702
+ if (this.kind === DERIVATIVE_ANTIMIROV) {
703
+ if (isReBinary(manager, first, OP_RE_UNION)) {
704
+ const left = this.mkInter(manager.getArg(first, 0), second);
705
+ const right = this.mkInter(manager.getArg(first, 1), second);
706
+ return this.mkUnion(left, right);
707
+ }
708
+ if (isReBinary(manager, second, OP_RE_UNION)) {
709
+ const left = this.mkInter(first, manager.getArg(second, 0));
710
+ const right = this.mkInter(first, manager.getArg(second, 1));
711
+ return this.mkUnion(left, right);
712
+ }
713
+ }
714
+ return this.re.mkInter(first, second);
715
+ }
716
+
717
+ private mkConcat(first: number, second: number) {
718
+ return this.re.mkReAppend(first, second);
719
+ }
720
+
721
+ private mkComplement(regex: number): number {
722
+ const pathExpr = this.pathExpr;
723
+ const cache = this.complementCaches[this.kind];
724
+ const cached = getPair(cache, regex, pathExpr);
725
+ if (cached !== undefined) return cached;
726
+ const result = this.mkComplementCore(regex);
727
+ setPair(cache, regex, pathExpr, result);
728
+ this.trail.push(regex);
729
+ this.trail.push(pathExpr);
730
+ this.trail.push(result);
731
+ return result;
732
+ }
733
+
734
+ private mkComplementCore(regex: number): number {
735
+ const manager = this.manager;
736
+ const sort = manager.sorts[regex];
737
+ if (isReUnary(manager, regex, OP_RE_COMPLEMENT)) return manager.getArg(regex, 0);
738
+ if (isReEmpty(manager, regex)) return mkFullSeq(manager, sort);
739
+ if (isFullSeq(manager, regex)) return mkReEmpty(manager, sort);
740
+ if (manager.getOp(regex) === OP_ITE) {
741
+ const [condition, thenExpr, elseExpr] = manager.getArgs(regex);
742
+ const result = this.applyIte(condition, thenExpr, elseExpr, (expr) =>
743
+ this.mkComplement(expr),
744
+ );
745
+ return result === -1 ? mkFullSeq(manager, sort) : result;
746
+ }
747
+ for (const op of [OP_RE_UNION, OP_RE_INTERSECT]) {
748
+ if (!isReBinary(manager, regex, op)) continue;
749
+ const first = this.mkComplement(manager.getArg(regex, 0));
750
+ const second = this.mkComplement(manager.getArg(regex, 1));
751
+ return op === OP_RE_UNION ? this.mkInter(first, second) : this.mkUnion(first, second);
752
+ }
753
+ return this.re.mkComplement(regex);
754
+ }
755
+
756
+ private mkIte(condition: number, thenExpr: number, elseExpr: number) {
757
+ const manager = this.manager;
758
+ if (manager.isTrue(condition) || thenExpr === elseExpr) return thenExpr;
759
+ if (manager.isFalse(condition)) return elseExpr;
760
+ const value = this.evalPathCond(condition);
761
+ if (value === L_TRUE) return thenExpr;
762
+ if (value === L_FALSE) return elseExpr;
763
+ return manager.mkApp(OP_ITE, [condition, thenExpr, elseExpr], manager.sorts[thenExpr]);
764
+ }
765
+
766
+ private mkDerivConcat(derivative: number, tail: number): number {
767
+ const cache = this.concatCaches[this.kind];
768
+ const cached = getPair(cache, derivative, tail);
769
+ if (cached !== undefined) return cached;
770
+ const result = this.mkDerivConcatCore(derivative, tail);
771
+ setPair(cache, derivative, tail, result);
772
+ this.trail.push(derivative);
773
+ this.trail.push(tail);
774
+ this.trail.push(result);
775
+ return result;
776
+ }
777
+
778
+ private mkDerivConcatCore(derivative: number, tail: number): number {
779
+ const manager = this.manager;
780
+ if (isReEmpty(manager, derivative)) return derivative;
781
+ if (isEpsilon(manager, derivative)) return tail;
782
+ if (manager.getOp(derivative) === OP_ITE) {
783
+ const thenConcat = this.mkDerivConcat(manager.getArg(derivative, 1), tail);
784
+ const elseConcat = this.mkDerivConcat(manager.getArg(derivative, 2), tail);
785
+ return this.mkIte(manager.getArg(derivative, 0), thenConcat, elseConcat);
786
+ }
787
+ if (this.kind === DERIVATIVE_ANTIMIROV && isReBinary(manager, derivative, OP_RE_UNION)) {
788
+ const left = this.mkDerivConcat(manager.getArg(derivative, 0), tail);
789
+ const right = this.mkDerivConcat(manager.getArg(derivative, 1), tail);
790
+ return this.mkUnion(left, right);
791
+ }
792
+ return this.mkConcat(derivative, tail);
793
+ }
794
+
795
+ private restorePath(pathSize: number, intervalsSize: number, intervalsStart: number) {
796
+ this.pathConds.length = pathSize;
797
+ this.pathSigns.length = pathSize;
798
+ this.intervals.length = 2 * intervalsSize;
799
+ this.intervalsStart = intervalsStart;
800
+ }
801
+
802
+ private push(condition: number, isNegated: boolean) {
803
+ const manager = this.manager;
804
+ const value = this.evalPathCond(condition);
805
+ if (value !== L_UNDEF) return (value === L_TRUE) !== isNegated ? L_TRUE : L_FALSE;
806
+ const pathSize = this.pathConds.length;
807
+ const intervalsSize = this.intervals.length / 2;
808
+ const intervalsStart = this.intervalsStart;
809
+ const pathExpr = this.pathExpr;
810
+ let result = this.pushPathAtoms(condition, isNegated);
811
+ if (result === L_UNDEF) result = this.pushIntervals(condition, isNegated);
812
+ if (result !== L_UNDEF) {
813
+ this.restorePath(pathSize, intervalsSize, intervalsStart);
814
+ return result;
815
+ }
816
+ const atom = isNegated ? manager.mkApp(OP_NOT, [condition], SORT_BOOL) : condition;
817
+ this.pathExpr = assign(manager, pathExpr, manager.mkApp(OP_AND, [pathExpr, atom], SORT_BOOL));
818
+ this.trail.push(this.pathExpr);
819
+ this.pathStack.push(pathSize, intervalsSize, intervalsStart, pathExpr);
820
+ return L_UNDEF;
821
+ }
822
+
823
+ private pop() {
824
+ const stack = this.pathStack;
825
+ const pathExpr = stack.pop()!;
826
+ const intervalsStart = stack.pop()!;
827
+ const intervalsSize = stack.pop()!;
828
+ const pathSize = stack.pop()!;
829
+ this.restorePath(pathSize, intervalsSize, intervalsStart);
830
+ this.pathExpr = assign(this.manager, this.pathExpr, pathExpr);
831
+ }
832
+
833
+ private applyIteBranches(condition: number, getThen: () => number, getElse: () => number) {
834
+ let thenBranch = -1;
835
+ let elseBranch = -1;
836
+ const thenStatus = this.push(condition, false);
837
+ if (thenStatus === L_TRUE) return getThen();
838
+ if (thenStatus === L_UNDEF) {
839
+ thenBranch = getThen();
840
+ this.pop();
841
+ }
842
+ const elseStatus = this.push(condition, true);
843
+ if (elseStatus === L_TRUE) return getElse();
844
+ if (elseStatus === L_UNDEF) {
845
+ elseBranch = getElse();
846
+ this.pop();
847
+ }
848
+ if (thenBranch !== -1 && elseBranch !== -1)
849
+ return this.mkIte(condition, thenBranch, elseBranch);
850
+ return thenBranch !== -1 ? thenBranch : elseBranch;
851
+ }
852
+
853
+ private applyIte(
854
+ condition: number,
855
+ thenExpr: number,
856
+ elseExpr: number,
857
+ apply: (expr: number) => number,
858
+ ) {
859
+ return this.applyIteBranches(
860
+ condition,
861
+ () => apply(thenExpr),
862
+ () => apply(elseExpr),
863
+ );
864
+ }
865
+
866
+ private hoistIte(
867
+ inputFirst: number,
868
+ inputSecond: number,
869
+ apply: (first: number, second: number) => number,
870
+ ) {
871
+ const manager = this.manager;
872
+ const isIte = (expr: number) => manager.getOp(expr) === OP_ITE;
873
+ const isSwapped =
874
+ isIte(inputFirst) &&
875
+ isIte(inputSecond) &&
876
+ manager.ids[manager.getArg(inputFirst, 0)] > manager.ids[manager.getArg(inputSecond, 0)];
877
+ const first = isSwapped ? inputSecond : inputFirst;
878
+ const second = isSwapped ? inputFirst : inputSecond;
879
+ const getOr = (result: number) =>
880
+ result === -1 ? mkReEmpty(manager, manager.sorts[first]) : result;
881
+ if (isIte(first) && isIte(second)) {
882
+ const [condition, firstThen, firstElse] = manager.getArgs(first);
883
+ if (condition === manager.getArg(second, 0))
884
+ return getOr(
885
+ this.applyIteBranches(
886
+ condition,
887
+ () => apply(firstThen, manager.getArg(second, 1)),
888
+ () => apply(firstElse, manager.getArg(second, 2)),
889
+ ),
890
+ );
891
+ return getOr(
892
+ this.applyIteBranches(
893
+ condition,
894
+ () => apply(firstThen, second),
895
+ () => apply(firstElse, second),
896
+ ),
897
+ );
898
+ }
899
+ if (isIte(first)) {
900
+ const [condition, thenExpr, elseExpr] = manager.getArgs(first);
901
+ return getOr(
902
+ this.applyIteBranches(
903
+ condition,
904
+ () => apply(thenExpr, second),
905
+ () => apply(elseExpr, second),
906
+ ),
907
+ );
908
+ }
909
+ if (isIte(second)) {
910
+ const [condition, thenExpr, elseExpr] = manager.getArgs(second);
911
+ return getOr(
912
+ this.applyIteBranches(
913
+ condition,
914
+ () => apply(thenExpr, first),
915
+ () => apply(elseExpr, first),
916
+ ),
917
+ );
918
+ }
919
+ return -1;
920
+ }
921
+
922
+ private pushPathAtoms(condition: number, isNegated: boolean): number {
923
+ const manager = this.manager;
924
+ const getEqSides = (expr: number) => {
925
+ if (manager.getOp(expr) !== OP_EQ) return undefined;
926
+ const lhs = manager.getArg(expr, 0);
927
+ const rhs = manager.getArg(expr, 1);
928
+ return manager.isValue(lhs) ? [rhs, lhs] : [lhs, rhs];
929
+ };
930
+ for (let index = 0; index < this.pathConds.length; index++) {
931
+ const cond = this.pathConds[index];
932
+ const isCondNegated = this.pathSigns[index];
933
+ if (condition === cond) return isCondNegated === isNegated ? L_TRUE : L_FALSE;
934
+ const first = isCondNegated ? undefined : getEqSides(cond);
935
+ const second = first === undefined ? undefined : getEqSides(condition);
936
+ if (
937
+ first !== undefined &&
938
+ second !== undefined &&
939
+ first[0] === second[0] &&
940
+ manager.areDistinct(first[1], second[1])
941
+ )
942
+ return isNegated ? L_TRUE : L_FALSE;
943
+ }
944
+ const op = manager.getOp(condition);
945
+ if ((!isNegated && op === OP_AND) || (isNegated && op === OP_OR)) {
946
+ let isAllImplied = true;
947
+ for (const arg of manager.getArgs(condition)) {
948
+ const result = this.pushPathAtoms(arg, isNegated);
949
+ if (result === L_FALSE) return L_FALSE;
950
+ if (result === L_UNDEF) isAllImplied = false;
951
+ }
952
+ return isAllImplied ? L_TRUE : L_UNDEF;
953
+ }
954
+ this.pathConds.push(condition);
955
+ this.pathSigns.push(isNegated);
956
+ return L_UNDEF;
957
+ }
958
+
959
+ private getIntervalsCount() {
960
+ return this.intervals.length / 2 - this.intervalsStart;
961
+ }
962
+
963
+ private pushIntervals(condition: number, isNegated: boolean): number {
964
+ const manager = this.manager;
965
+ const range = getCharConstRange(manager, this.element, condition);
966
+ const intervals = this.intervals;
967
+ const end = intervals.length / 2;
968
+ const op = manager.getOp(condition);
969
+ if (range !== undefined) {
970
+ if (range.isNegated === isNegated) {
971
+ if (range.lo > range.hi) return L_FALSE;
972
+ let isSubset = true;
973
+ for (let index = this.intervalsStart; index < end; index++)
974
+ if (intervals[2 * index] < range.lo || intervals[2 * index + 1] > range.hi) {
975
+ isSubset = false;
976
+ break;
977
+ }
978
+ if (isSubset) return L_TRUE;
979
+ this.intersectIntervals(range.lo, range.hi);
980
+ } else if (range.lo <= range.hi) {
981
+ let isExcluded = true;
982
+ for (let index = this.intervalsStart; index < end; index++)
983
+ if (intervals[2 * index] <= range.hi && intervals[2 * index + 1] >= range.lo) {
984
+ isExcluded = false;
985
+ break;
986
+ }
987
+ if (isExcluded) return L_TRUE;
988
+ this.excludeInterval(range.lo, range.hi);
989
+ }
990
+ } else if ((!isNegated && op === OP_AND) || (isNegated && op === OP_OR)) {
991
+ let isAllImplied = true;
992
+ for (const arg of manager.getArgs(condition)) {
993
+ const result = this.pushIntervals(arg, isNegated);
994
+ if (result === L_FALSE) return L_FALSE;
995
+ if (result === L_UNDEF) isAllImplied = false;
996
+ }
997
+ return isAllImplied ? L_TRUE : this.getIntervalsCount() === 0 ? L_FALSE : L_UNDEF;
998
+ }
999
+ return this.getIntervalsCount() === 0 ? L_FALSE : L_UNDEF;
1000
+ }
1001
+
1002
+ private evalPathCond(condition: number) {
1003
+ const value = this.evalCond(condition);
1004
+ if (value !== L_UNDEF) return value;
1005
+ for (let index = 0; index < this.pathConds.length; index++)
1006
+ if (this.pathConds[index] === condition) return this.pathSigns[index] ? L_FALSE : L_TRUE;
1007
+ const rangeValue = this.evalRangeCond(condition);
1008
+ if (rangeValue !== L_UNDEF) return rangeValue;
1009
+ for (let index = 0; index < this.pathConds.length; index++) {
1010
+ if (this.isPredImplying(this.pathSigns[index], this.pathConds[index], false, condition))
1011
+ return L_TRUE;
1012
+ if (this.isPredImplying(this.pathSigns[index], this.pathConds[index], true, condition))
1013
+ return L_FALSE;
1014
+ }
1015
+ return L_UNDEF;
1016
+ }
1017
+
1018
+ private evalCond(condition: number): number {
1019
+ const manager = this.manager;
1020
+ if (manager.isTrue(condition)) return L_TRUE;
1021
+ if (manager.isFalse(condition)) return L_FALSE;
1022
+ const range = getCharConstRange(manager, this.element, condition);
1023
+ const elementCode = manager.getChar(this.element);
1024
+ if (range !== undefined && elementCode !== -1)
1025
+ return (range.lo <= elementCode && elementCode <= range.hi) !== range.isNegated
1026
+ ? L_TRUE
1027
+ : L_FALSE;
1028
+ const op = manager.getOp(condition);
1029
+ if (op === OP_EQ && manager.getArg(condition, 0) === manager.getArg(condition, 1))
1030
+ return L_TRUE;
1031
+ if (op === OP_CHAR_LE) {
1032
+ const lhs = manager.getChar(manager.getArg(condition, 0));
1033
+ const rhs = manager.getChar(manager.getArg(condition, 1));
1034
+ if (lhs !== -1 && rhs !== -1) return lhs <= rhs ? L_TRUE : L_FALSE;
1035
+ if (lhs === 0 || rhs === this.manager.maxChar) return L_TRUE;
1036
+ }
1037
+ if (op === OP_NOT) return -this.evalCond(manager.getArg(condition, 0));
1038
+ if (op !== OP_AND && op !== OP_OR) return L_UNDEF;
1039
+ const absorbing = op === OP_AND ? L_FALSE : L_TRUE;
1040
+ let result = -absorbing;
1041
+ for (const arg of manager.getArgs(condition)) {
1042
+ const value = this.evalCond(arg);
1043
+ if (value === absorbing) return absorbing;
1044
+ if (value === L_UNDEF) result = L_UNDEF;
1045
+ }
1046
+ return result;
1047
+ }
1048
+
1049
+ private evalRangeCond(condition: number) {
1050
+ if (this.getIntervalsCount() === 0) return L_FALSE;
1051
+ const range = getCharConstRange(this.manager, this.element, condition);
1052
+ if (range === undefined) return L_UNDEF;
1053
+ if (range.lo > range.hi) return range.isNegated ? L_TRUE : L_FALSE;
1054
+ let isAnyOverlap = false;
1055
+ let isAllContained = true;
1056
+ const intervals = this.intervals;
1057
+ for (let index = this.intervalsStart; index < intervals.length / 2; index++) {
1058
+ const lo = intervals[2 * index];
1059
+ const hi = intervals[2 * index + 1];
1060
+ if (Math.max(lo, range.lo) <= Math.min(hi, range.hi)) isAnyOverlap = true;
1061
+ if (lo < range.lo || hi > range.hi) isAllContained = false;
1062
+ }
1063
+ if (!range.isNegated) {
1064
+ if (!isAnyOverlap) return L_FALSE;
1065
+ if (isAllContained) return L_TRUE;
1066
+ } else {
1067
+ if (isAllContained) return L_FALSE;
1068
+ if (!isAnyOverlap) return L_TRUE;
1069
+ }
1070
+ return L_UNDEF;
1071
+ }
1072
+
1073
+ private intersectIntervals(lo: number, hi: number) {
1074
+ const intervals = this.intervals;
1075
+ const oldSize = intervals.length / 2;
1076
+ for (let index = this.intervalsStart; index < oldSize; index++)
1077
+ intervals.push(intervals[2 * index], intervals[2 * index + 1]);
1078
+ this.intervalsStart = oldSize;
1079
+ let next = oldSize;
1080
+ for (let index = oldSize; index < intervals.length / 2; index++) {
1081
+ const intervalLo = intervals[2 * index];
1082
+ const intervalHi = intervals[2 * index + 1];
1083
+ if (hi < intervalLo || lo > intervalHi) continue;
1084
+ intervals[2 * next] = Math.max(intervalLo, lo);
1085
+ intervals[2 * next + 1] = Math.min(intervalHi, hi);
1086
+ next++;
1087
+ }
1088
+ intervals.length = 2 * next;
1089
+ }
1090
+
1091
+ private excludeInterval(lo: number, hi: number) {
1092
+ const maxChar = this.manager.maxChar;
1093
+ const intervals = this.intervals;
1094
+ if (lo === 0 && hi >= maxChar) {
1095
+ this.intervalsStart = intervals.length / 2;
1096
+ return;
1097
+ }
1098
+ if (lo === 0) {
1099
+ this.intersectIntervals(hi + 1, maxChar);
1100
+ return;
1101
+ }
1102
+ if (hi >= maxChar) {
1103
+ this.intersectIntervals(0, lo - 1);
1104
+ return;
1105
+ }
1106
+ const oldSize = intervals.length / 2;
1107
+ for (let index = this.intervalsStart; index < oldSize; index++) {
1108
+ const intervalLo = intervals[2 * index];
1109
+ const intervalHi = intervals[2 * index + 1];
1110
+ if (intervalHi < lo || intervalLo > hi) {
1111
+ intervals.push(intervalLo, intervalHi);
1112
+ continue;
1113
+ }
1114
+ if (intervalLo < lo) intervals.push(intervalLo, lo - 1);
1115
+ if (intervalHi > hi) intervals.push(hi + 1, intervalHi);
1116
+ }
1117
+ this.intervalsStart = oldSize;
1118
+ }
1119
+
1120
+ private cleanLeaf(regex: number) {
1121
+ const manager = this.manager;
1122
+ const cache = new Map<number, number>();
1123
+ const todo = [regex];
1124
+ while (todo.length > 0) {
1125
+ const expr = todo[todo.length - 1];
1126
+ if (cache.has(expr)) {
1127
+ todo.pop();
1128
+ continue;
1129
+ }
1130
+ if (
1131
+ manager.kinds[expr] !== KIND_APP ||
1132
+ !manager.isReSort(manager.sorts[expr]) ||
1133
+ isReOp(manager, expr, OP_RE_DERIVATIVE)
1134
+ ) {
1135
+ cache.set(expr, expr);
1136
+ todo.pop();
1137
+ continue;
1138
+ }
1139
+ const exprArgs = manager.getArgs(expr);
1140
+ let isReady = true;
1141
+ for (const arg of exprArgs)
1142
+ if (!cache.has(arg)) {
1143
+ todo.push(arg);
1144
+ isReady = false;
1145
+ }
1146
+ if (!isReady) continue;
1147
+ const args = exprArgs.map((arg) => cache.get(arg)!);
1148
+ const result =
1149
+ args.length === 2 && isReOp(manager, expr, OP_RE_UNION)
1150
+ ? this.mkUnion(args[0], args[1])
1151
+ : args.length === 2 && isReOp(manager, expr, OP_RE_INTERSECT)
1152
+ ? this.mkInter(args[0], args[1])
1153
+ : args.length === 2 && isReOp(manager, expr, OP_RE_XOR)
1154
+ ? this.mkXor(args[0], args[1])
1155
+ : isReOp(manager, expr, OP_RE_COMPLEMENT)
1156
+ ? this.mkComplement(args[0])
1157
+ : this.re.mkApp(manager.decls[expr], args);
1158
+ cache.set(expr, result);
1159
+ todo.pop();
1160
+ }
1161
+ return cache.get(regex)!;
1162
+ }
1163
+
1164
+ private decomposeIte(regex: number): Decomposed | undefined {
1165
+ const manager = this.manager;
1166
+ if (manager.getOp(regex) === OP_ITE) {
1167
+ const parts = manager.getArgs(regex);
1168
+ for (const part of parts) manager.incRef(part);
1169
+ return { condition: parts[0], thenExpr: parts[1], elseExpr: parts[2] };
1170
+ }
1171
+ const visited = new Set<number>();
1172
+ const stack = [regex];
1173
+ while (stack.length > 0) {
1174
+ const expr = stack[stack.length - 1];
1175
+ if (manager.getOp(expr) === OP_ITE) {
1176
+ const first = this.firstReplace;
1177
+ const second = this.secondReplace;
1178
+ first.reset();
1179
+ second.reset();
1180
+ first.insert(expr, manager.getArg(expr, 1));
1181
+ second.insert(expr, manager.getArg(expr, 2));
1182
+ const condition = manager.getArg(expr, 0);
1183
+ manager.incRef(condition);
1184
+ return { condition, thenExpr: first.apply(regex), elseExpr: second.apply(regex) };
1185
+ }
1186
+ visited.add(expr);
1187
+ if (manager.kinds[expr] === KIND_APP) stack.push(...manager.getArgs(expr));
1188
+ while (stack.length > 0 && visited.has(stack[stack.length - 1])) stack.pop();
1189
+ }
1190
+ return undefined;
1191
+ }
1192
+
1193
+ private getCofactorsRec(regex: number, result: RefVector) {
1194
+ const manager = this.manager;
1195
+ let decomposed = this.decomposeIte(regex);
1196
+ if (decomposed === undefined) {
1197
+ const cleaned = this.cleanLeaf(regex);
1198
+ manager.incRef(cleaned);
1199
+ decomposed = this.decomposeIte(cleaned);
1200
+ if (decomposed === undefined && !isReEmpty(manager, cleaned)) {
1201
+ result.push(this.pathExpr);
1202
+ result.push(cleaned);
1203
+ }
1204
+ manager.decRef(cleaned);
1205
+ if (decomposed === undefined) return;
1206
+ }
1207
+ const parts = decomposed;
1208
+ const thenStatus = this.push(parts.condition, false);
1209
+ if (thenStatus !== L_FALSE) this.getCofactorsRec(parts.thenExpr, result);
1210
+ if (thenStatus === L_UNDEF) this.pop();
1211
+ const elseStatus = this.push(parts.condition, true);
1212
+ if (elseStatus !== L_FALSE) this.getCofactorsRec(parts.elseExpr, result);
1213
+ if (elseStatus === L_UNDEF) this.pop();
1214
+ for (const part of [parts.elseExpr, parts.thenExpr, parts.condition]) manager.decRef(part);
1215
+ }
1216
+
1217
+ getCofactors(element: number, regex: number, result: RefVector) {
1218
+ if (element !== this.element) this.resetOpCaches();
1219
+ this.element = assign(this.manager, this.element, element);
1220
+ this.trail.push(element);
1221
+ this.trail.push(regex);
1222
+ this.pathStack.length = 0;
1223
+ this.resetPath();
1224
+ this.getCofactorsRec(regex, result);
1225
+ }
1226
+
1227
+ getCachedCofactors(mode: number, regex: number) {
1228
+ const cache =
1229
+ mode === TRANSITION_LIGHT_ANTIMIROV ? this.antCofactorCache : this.brzCofactorCache;
1230
+ const cached = cache.cofactors.get(regex);
1231
+ if (cached !== undefined) return cached;
1232
+ const cofactors = new RefVector(this.manager);
1233
+ if (mode === TRANSITION_LIGHT_ANTIMIROV) this.lightAntDerivativeCofactors(regex, cofactors);
1234
+ else this.derivativeCofactors(regex, cofactors);
1235
+ cache.insert(regex, cofactors);
1236
+ return cofactors;
1237
+ }
1238
+
1239
+ maybeResetCachedCofactors(cap: number) {
1240
+ this.brzCofactorCache.maybeReset(cap);
1241
+ this.antCofactorCache.maybeReset(cap);
1242
+ }
1243
+
1244
+ derivativeCofactors(regex: number, result: RefVector) {
1245
+ const manager = this.manager;
1246
+ const elementSort = manager.getSeqElementSort(manager.getReSeqSort(manager.sorts[regex]));
1247
+ const element = manager.mkVar(0, elementSort);
1248
+ const derivative = this.derive(DERIVATIVE_BRZOZOWSKI, element, regex);
1249
+ // Deviation from Z3: a cached derivative leaves m_ele null there, which stops the pruning.
1250
+ this.getCofactors(element, derivative, result);
1251
+ }
1252
+
1253
+ lightAntDerivativeCofactors(regex: number, result: RefVector) {
1254
+ const manager = this.manager;
1255
+ const brzozowski = new RefVector(manager);
1256
+ this.derivativeCofactors(regex, brzozowski);
1257
+ const targetIndex = new Map<number, number>();
1258
+ const guards: number[] = [];
1259
+ const targets: number[] = [];
1260
+ const add = (guard: number, target: number) => {
1261
+ const index = targetIndex.get(target);
1262
+ if (index !== undefined) {
1263
+ guards[index] = this.bool.mkOr([guards[index], guard]);
1264
+ return;
1265
+ }
1266
+ targetIndex.set(target, targets.length);
1267
+ targets.push(target);
1268
+ guards.push(guard);
1269
+ };
1270
+ for (let pair = 0; pair < brzozowski.size; pair += 2) {
1271
+ const guard = brzozowski.items[pair];
1272
+ const pending = [brzozowski.items[pair + 1]];
1273
+ for (let target = pending.pop(); target !== undefined; target = pending.pop()) {
1274
+ if (isReBinary(manager, target, OP_RE_UNION)) {
1275
+ pending.push(manager.getArg(target, 1), manager.getArg(target, 0));
1276
+ continue;
1277
+ }
1278
+ const isSplit =
1279
+ isReBinary(manager, target, OP_RE_CONCAT) &&
1280
+ isReOp(manager, manager.getArg(target, 0), OP_RE_UNION);
1281
+ if (!isSplit) {
1282
+ add(guard, target);
1283
+ continue;
1284
+ }
1285
+ const tail = manager.getArg(target, 1);
1286
+ const heads = [manager.getArg(target, 0)];
1287
+ for (let current = heads.pop(); current !== undefined; current = heads.pop()) {
1288
+ if (isReBinary(manager, current, OP_RE_UNION))
1289
+ heads.push(manager.getArg(current, 1), manager.getArg(current, 0));
1290
+ else add(guard, this.re.mkReAppend(current, tail));
1291
+ }
1292
+ }
1293
+ }
1294
+ result.reset();
1295
+ for (let index = 0; index < targets.length; index++) {
1296
+ result.push(guards[index]);
1297
+ result.push(targets[index]);
1298
+ }
1299
+ brzozowski.reset();
1300
+ }
1301
+ }