tla-ts 0.0.9 → 0.0.10-dev.09e53c2a6
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.
- package/README.md +30 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +57 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +109 -10
- package/dist/index.d.ts +109 -10
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2746 -410
- package/dist/prove.js +2745 -409
- package/dist/run.cjs +146 -31
- package/dist/run.js +146 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +132 -104
- package/dist/transfer.js +132 -104
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +3 -1
- package/src/ast.ts +45 -59
- package/src/bags.ts +99 -102
- package/src/builtins.ts +28 -75
- package/src/bundled-modules.ts +1 -8
- package/src/check-failure.ts +116 -0
- package/src/check-trace.ts +282 -0
- package/src/check.ts +797 -782
- package/src/cli/options.ts +12 -32
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +136 -0
- package/src/cli/shared.ts +19 -12
- package/src/cli/tlapm.ts +433 -82
- package/src/cli/tlc-arguments.ts +652 -0
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +360 -0
- package/src/cli/tlc.ts +323 -658
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +27 -49
- package/src/cli.ts +0 -1
- package/src/codegen.ts +196 -74
- package/src/config.ts +140 -109
- package/src/coverage.ts +830 -0
- package/src/dependencies.ts +36 -54
- package/src/dfid.ts +618 -0
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +178 -339
- package/src/errors.ts +100 -57
- package/src/evaluate.ts +598 -340
- package/src/exit-codes.ts +38 -3
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +126 -21
- package/src/java-hash.ts +7 -0
- package/src/java-overrides.ts +4 -19
- package/src/json-reader.ts +455 -0
- package/src/json.ts +252 -139
- package/src/levels.ts +46 -58
- package/src/lexer.ts +83 -101
- package/src/liveness-checker.ts +590 -311
- package/src/liveness.ts +180 -124
- package/src/obligations/action.ts +17 -44
- package/src/obligations/anonymize.ts +120 -95
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +37 -26
- package/src/obligations/format.ts +0 -10
- package/src/obligations/generate.ts +66 -64
- package/src/obligations/index.ts +38 -19
- package/src/obligations/levels.ts +27 -18
- package/src/obligations/module.ts +28 -55
- package/src/obligations/normalize.ts +30 -37
- package/src/obligations/operators.ts +0 -3
- package/src/obligations/pragma.ts +52 -24
- package/src/obligations/printer.ts +89 -58
- package/src/obligations/proof.ts +3 -6
- package/src/obligations/regroup.ts +0 -5
- package/src/obligations/simplify.ts +57 -63
- package/src/obligations/source.ts +119 -95
- package/src/obligations/subexpression.ts +49 -28
- package/src/obligations/substitution.ts +1 -5
- package/src/obligations/temporal.ts +12 -20
- package/src/obligations/tuples.ts +2 -10
- package/src/parallel-worker.ts +30 -60
- package/src/parallel.ts +59 -73
- package/src/parser.ts +1082 -399
- package/src/pcal/ast.ts +53 -86
- package/src/pcal/parse.ts +144 -219
- package/src/pcal/tokenize.ts +91 -131
- package/src/pcal/translate.ts +83 -130
- package/src/pcal/validate.ts +48 -68
- package/src/pretty-print.ts +7 -8
- package/src/prover/decide-pool.ts +8 -13
- package/src/prover/deciders.ts +12 -13
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +3 -31
- package/src/prover/isabelle/encode.ts +82 -64
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
- package/src/prover/isabelle/isar/method.ts +510 -226
- package/src/prover/isabelle/isar/proof.ts +570 -23
- package/src/prover/isabelle/isar/rule-cases.ts +224 -0
- package/src/prover/isabelle/isar/theory.ts +488 -88
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +99 -38
- package/src/prover/isabelle/provers/blast/blast.ts +16 -105
- package/src/prover/isabelle/provers/blast/branch.ts +0 -33
- package/src/prover/isabelle/provers/blast/prove.ts +0 -36
- package/src/prover/isabelle/provers/blast/rules.ts +5 -45
- package/src/prover/isabelle/provers/blast/state.ts +1 -29
- package/src/prover/isabelle/provers/blast/term.ts +8 -37
- package/src/prover/isabelle/provers/clasimp.ts +0 -14
- package/src/prover/isabelle/provers/classical.ts +58 -61
- package/src/prover/isabelle/provers/hypsubst.ts +27 -52
- package/src/prover/isabelle/pure/bicompose.ts +24 -39
- package/src/prover/isabelle/pure/consts.ts +0 -8
- package/src/prover/isabelle/pure/conv.ts +2 -18
- package/src/prover/isabelle/pure/drule.ts +95 -45
- package/src/prover/isabelle/pure/envir.ts +2 -53
- package/src/prover/isabelle/pure/goal.ts +1 -9
- package/src/prover/isabelle/pure/interrupt.ts +0 -5
- package/src/prover/isabelle/pure/list.ts +0 -3
- package/src/prover/isabelle/pure/logic.ts +1 -16
- package/src/prover/isabelle/pure/name.ts +1 -10
- package/src/prover/isabelle/pure/net.ts +2 -60
- package/src/prover/isabelle/pure/object-logic.ts +15 -16
- package/src/prover/isabelle/pure/pattern.ts +1 -20
- package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
- package/src/prover/isabelle/pure/rewriter.ts +31 -74
- package/src/prover/isabelle/pure/search.ts +2 -11
- package/src/prover/isabelle/pure/seq.ts +0 -11
- package/src/prover/isabelle/pure/simplifier.ts +27 -16
- package/src/prover/isabelle/pure/table.ts +2 -33
- package/src/prover/isabelle/pure/tactic.ts +11 -23
- package/src/prover/isabelle/pure/tactical.ts +47 -48
- package/src/prover/isabelle/pure/term-ord.ts +1 -7
- package/src/prover/isabelle/pure/term.ts +1 -44
- package/src/prover/isabelle/pure/thm.ts +26 -48
- package/src/prover/isabelle/pure/type.ts +1 -16
- package/src/prover/isabelle/pure/unify.ts +19 -31
- package/src/prover/isabelle/pure/variable.ts +2 -8
- package/src/prover/isabelle/tla/classical-setup.ts +17 -25
- package/src/prover/isabelle/tla/context.ts +65 -26
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +53 -32
- package/src/prover/isabelle/tla/simpdata.ts +45 -44
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
- package/src/prover/ocaml.ts +4 -7
- package/src/prover/prep/action.ts +33 -66
- package/src/prover/prep/enabled-axioms.ts +22 -20
- package/src/prover/prep/fingerprint.ts +2 -21
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +0 -2
- package/src/prover/prep/methods.ts +189 -86
- package/src/prover/prep/normalize.ts +42 -37
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +398 -133
- package/src/prover/ptl/decide.ts +96 -56
- package/src/prover/ptl/encode.ts +15 -38
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +40 -28
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -15
- package/src/prover/smt/context.ts +60 -32
- package/src/prover/smt/data.ts +517 -401
- package/src/prover/smt/encode.ts +155 -85
- package/src/prover/smt/extensionality.ts +5 -13
- package/src/prover/smt/flatten.ts +7 -28
- package/src/prover/smt/format.ts +33 -14
- package/src/prover/smt/instances.ts +7 -11
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1026 -658
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -16
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +615 -53
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +309 -0
- package/src/prover/smt/solver/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +87 -58
- package/src/prover/smt/solver/ast-lt.ts +166 -22
- package/src/prover/smt/solver/ast-util.ts +160 -7
- package/src/prover/smt/solver/ast.ts +1424 -180
- package/src/prover/smt/solver/auf-solver.ts +7 -44
- package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +600 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +110 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -10
- package/src/prover/smt/solver/cg-table.ts +39 -42
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -27
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -11
- package/src/prover/smt/solver/context.ts +519 -175
- package/src/prover/smt/solver/ctx-simplify.ts +33 -50
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
- package/src/prover/smt/solver/der.ts +39 -30
- package/src/prover/smt/solver/diff-neq.ts +206 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -11
- package/src/prover/smt/solver/e-matching.ts +9 -41
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +545 -0
- package/src/prover/smt/solver/enode.ts +100 -23
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +907 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1205 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1050 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +830 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +335 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
- package/src/prover/smt/solver/expr2polynomial.ts +146 -0
- package/src/prover/smt/solver/factor.ts +141 -0
- package/src/prover/smt/solver/fd-solver.ts +265 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -26
- package/src/prover/smt/solver/fix-dl-var.ts +148 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -9
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +640 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2249 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +176 -28
- package/src/prover/smt/solver/goal2nlsat.ts +189 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -9
- package/src/prover/smt/solver/hashtable.ts +26 -23
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +112 -132
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -2
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -4
- package/src/prover/smt/solver/logic-tactics.ts +345 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
- package/src/prover/smt/solver/lp/constraints.ts +1 -8
- package/src/prover/smt/solver/lp/containers.ts +11 -30
- package/src/prover/smt/solver/lp/core-solver.ts +23 -29
- package/src/prover/smt/solver/lp/cross-nested.ts +5 -20
- package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
- package/src/prover/smt/solver/lp/dependency.ts +0 -5
- package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
- package/src/prover/smt/solver/lp/explanation.ts +0 -6
- package/src/prover/smt/solver/lp/gomory.ts +8 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
- package/src/prover/smt/solver/lp/hnf.ts +10 -28
- package/src/prover/smt/solver/lp/int-cube.ts +17 -39
- package/src/prover/smt/solver/lp/int-solver.ts +3 -35
- package/src/prover/smt/solver/lp/lar-solver.ts +69 -82
- package/src/prover/smt/solver/lp/lar-term.ts +0 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -14
- package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
- package/src/prover/smt/solver/lp/nex-creator.ts +4 -28
- package/src/prover/smt/solver/lp/nex.ts +0 -6
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
- package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
- package/src/prover/smt/solver/lp/nla-core.ts +91 -135
- package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
- package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +22 -72
- package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
- package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
- package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
- package/src/prover/smt/solver/lp/nla-order.ts +0 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -12
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
- package/src/prover/smt/solver/lp/nra-solver.ts +123 -112
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +0 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +1 -14
- package/src/prover/smt/solver/lp/pdd-solver.ts +2 -33
- package/src/prover/smt/solver/lp/pdd.ts +7 -70
- package/src/prover/smt/solver/lp/random-updater.ts +0 -9
- package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
- package/src/prover/smt/solver/lp/union-find.ts +5 -5
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +129 -139
- package/src/prover/smt/solver/mam-interpreter.ts +0 -21
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +309 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +105 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -62
- package/src/prover/smt/solver/model-evaluator.ts +190 -40
- package/src/prover/smt/solver/model-finder.ts +14 -32
- package/src/prover/smt/solver/model-generator.ts +56 -40
- package/src/prover/smt/solver/model-macro-solver.ts +60 -114
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +711 -0
- package/src/prover/smt/solver/mus.ts +51 -0
- package/src/prover/smt/solver/muz/dl-context.ts +404 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1406 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +218 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +177 -160
- package/src/prover/smt/solver/nlsat/atoms.ts +24 -24
- package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
- package/src/prover/smt/solver/nlsat/explain.ts +65 -69
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
- package/src/prover/smt/solver/nlsat/levelwise.ts +48 -135
- package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +29 -161
- package/src/prover/smt/solver/nlsat/solver.ts +241 -110
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +367 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -9
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -47
- package/src/prover/smt/solver/nlsat/upolynomial.ts +10 -93
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +107 -60
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +787 -0
- package/src/prover/smt/solver/opt-nlsat.ts +375 -0
- package/src/prover/smt/solver/opt-pareto.ts +282 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +308 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +21 -26
- package/src/prover/smt/solver/pb-rewriter.ts +284 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +204 -79
- package/src/prover/smt/solver/probes.ts +512 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -30
- package/src/prover/smt/solver/proto-model.ts +650 -66
- package/src/prover/smt/solver/pull-quant.ts +28 -23
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1098 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -31
- package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
- package/src/prover/smt/solver/qe-lite.ts +39 -49
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1498 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -16
- package/src/prover/smt/solver/qsat.ts +814 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +17 -74
- package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
- package/src/prover/smt/solver/quantifier-manager.ts +8 -23
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -2
- package/src/prover/smt/solver/rational.ts +45 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +261 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -6
- package/src/prover/smt/solver/relevancy.ts +2 -16
- package/src/prover/smt/solver/rewriter-tpl.ts +52 -129
- package/src/prover/smt/solver/rewriter.ts +477 -120
- package/src/prover/smt/solver/rlimit.ts +39 -21
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +43 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2127 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +1010 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1301 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +728 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1170 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2402 -0
- package/src/prover/smt/solver/seq-skolem.ts +317 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +83 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +496 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3140 -365
- package/src/prover/smt/solver/smtlib-script.ts +1631 -0
- package/src/prover/smt/solver/solve-eqs.ts +929 -0
- package/src/prover/smt/solver/solver.ts +119 -39
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -6
- package/src/prover/smt/solver/tactic.ts +1986 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1200 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
- package/src/prover/smt/solver/theory-lra-final-check.ts +59 -91
- package/src/prover/smt/solver/theory-lra-internalize.ts +94 -53
- package/src/prover/smt/solver/theory-lra-model.ts +23 -53
- package/src/prover/smt/solver/theory-lra-propagate.ts +24 -40
- package/src/prover/smt/solver/theory-lra-state.ts +6 -27
- package/src/prover/smt/solver/theory-lra.ts +188 -8
- package/src/prover/smt/solver/theory-pb.ts +934 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +871 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
- package/src/prover/smt/solver/var-subst.ts +37 -39
- package/src/prover/smt/table.ts +3 -10
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +67 -41
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +21 -20
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -2
- package/src/prover/zenon/check/check.ts +1 -11
- package/src/prover/zenon/check/definitions.ts +5 -15
- package/src/prover/zenon/check/equality.ts +0 -8
- package/src/prover/zenon/check/functions.ts +0 -4
- package/src/prover/zenon/check/keys.ts +0 -7
- package/src/prover/zenon/check/propositional.ts +0 -3
- package/src/prover/zenon/check/records.ts +1 -6
- package/src/prover/zenon/check/relations.ts +2 -14
- package/src/prover/zenon/check/rewrites.ts +2 -21
- package/src/prover/zenon/check/sets.ts +40 -61
- package/src/prover/zenon/check/terms.ts +1 -19
- package/src/prover/zenon/check/tla.ts +0 -6
- package/src/prover/zenon/decide.ts +10 -19
- package/src/prover/zenon/encode.ts +0 -9
- package/src/prover/zenon/eqrel.ts +2 -15
- package/src/prover/zenon/equality-rules.ts +0 -6
- package/src/prover/zenon/expr.ts +8 -28
- package/src/prover/zenon/index-table.ts +26 -59
- package/src/prover/zenon/isar-case.ts +8 -20
- package/src/prover/zenon/isar.ts +35 -65
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +2 -22
- package/src/prover/zenon/mltoll.ts +66 -106
- package/src/prover/zenon/node.ts +20 -15
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +9 -13
- package/src/prover/zenon/phrase.ts +1 -13
- package/src/prover/zenon/proof.ts +0 -11
- package/src/prover/zenon/propositional-rules.ts +0 -7
- package/src/prover/zenon/rules.ts +2 -8
- package/src/prover/zenon/search.ts +11 -35
- package/src/prover/zenon/tla/functions.ts +59 -33
- package/src/prover/zenon/tla/llproof.ts +67 -78
- package/src/prover/zenon/tla/records.ts +57 -35
- package/src/prover/zenon/tla/rewrites.ts +12 -21
- package/src/prover/zenon/tla/sets.ts +88 -59
- package/src/prover/zenon/tla/terms.ts +0 -8
- package/src/prover/zenon/tla/tla.ts +66 -66
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +67 -185
- package/src/runtime.ts +26 -22
- package/src/sany/builtins.ts +2 -5
- package/src/sany/generation.ts +394 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +686 -0
- package/src/sany/generator-expressions.ts +1100 -0
- package/src/sany/generator-proofs.ts +662 -0
- package/src/sany/generator.ts +191 -2764
- package/src/sany/levels.ts +5 -35
- package/src/sany/lexer.ts +58 -77
- package/src/sany/linter.ts +0 -10
- package/src/sany/modules.ts +1 -5
- package/src/sany/nodes.ts +5 -43
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +32 -69
- package/src/sany/selectors.ts +49 -76
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +35 -117
- package/src/search.ts +671 -169
- package/src/simulate.ts +712 -0
- package/src/spec-description.ts +192 -100
- package/src/standard-definitions.ts +4 -4
- package/src/standard-modules.ts +264 -95
- package/src/state-graph.ts +52 -33
- package/src/subexpressions.ts +69 -52
- package/src/substitution-levels.ts +7 -7
- package/src/successors.ts +267 -100
- package/src/symmetry.ts +35 -27
- package/src/tableau.ts +29 -26
- package/src/tlc/fingerprint.ts +267 -79
- package/src/tlc/jar-data.ts +112 -6
- package/src/tlc/messages.ts +125 -54
- package/src/tlc/order.ts +39 -69
- package/src/tlc/random.ts +37 -49
- package/src/tlc/replay.ts +553 -228
- package/src/tlc/summary.ts +64 -60
- package/src/tlc/tlc-operators.ts +78 -44
- package/src/tlc/tlcext-operators.ts +171 -122
- package/src/tlc/trace-spec.ts +249 -0
- package/src/tlc/value-stream.ts +139 -0
- package/src/tlc/version.ts +1 -4
- package/src/transfer.ts +22 -25
- package/src/typed-tier.ts +6535 -0
- package/src/typescript/actions.ts +479 -0
- package/src/typescript/collections.ts +614 -0
- package/src/typescript/compile.ts +63 -0
- package/src/typescript/context.ts +94 -0
- package/src/typescript/emit.ts +121 -0
- package/src/typescript/expressions.ts +496 -0
- package/src/typescript/formula.ts +154 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +162 -0
- package/src/typescript/names.ts +114 -0
- package/src/typescript/program.ts +48 -0
- package/src/typescript/properties.ts +139 -0
- package/src/typescript/scope.ts +112 -0
- package/src/typescript/steps.ts +167 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +832 -484
- package/src/worker.ts +7 -8
- package/src/prover/isabelle/isar/statement.ts +0 -57
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
|
@@ -0,0 +1,2402 @@
|
|
|
1
|
+
import { mkArrayApp } from "./array-decl-plugin";
|
|
2
|
+
import {
|
|
3
|
+
type AstManager,
|
|
4
|
+
FAMILY_CHAR,
|
|
5
|
+
KIND_APP,
|
|
6
|
+
KIND_VAR,
|
|
7
|
+
OP_ADD,
|
|
8
|
+
OP_AND,
|
|
9
|
+
OP_BNEG,
|
|
10
|
+
OP_CHAR_FROM_BV,
|
|
11
|
+
OP_CHAR_IS_DIGIT,
|
|
12
|
+
OP_CHAR_LE,
|
|
13
|
+
OP_CHAR_TO_INT,
|
|
14
|
+
OP_EQ,
|
|
15
|
+
OP_GE,
|
|
16
|
+
OP_ITE,
|
|
17
|
+
OP_LE,
|
|
18
|
+
OP_LT,
|
|
19
|
+
OP_MUL,
|
|
20
|
+
OP_NOT,
|
|
21
|
+
OP_OR,
|
|
22
|
+
OP_RE_COMPLEMENT,
|
|
23
|
+
OP_RE_EMPTY_SET,
|
|
24
|
+
OP_RE_FULL_CHAR_SET,
|
|
25
|
+
OP_RE_FULL_SEQ_SET,
|
|
26
|
+
OP_RE_INTERSECT,
|
|
27
|
+
OP_RE_OF_PRED,
|
|
28
|
+
OP_RE_UNION,
|
|
29
|
+
OP_SELECT,
|
|
30
|
+
OP_SEQ_AT,
|
|
31
|
+
OP_SEQ_CONCAT,
|
|
32
|
+
OP_SEQ_CONTAINS,
|
|
33
|
+
OP_SEQ_EMPTY,
|
|
34
|
+
OP_SEQ_EXTRACT,
|
|
35
|
+
OP_SEQ_FOLDL,
|
|
36
|
+
OP_SEQ_FOLDLI,
|
|
37
|
+
OP_SEQ_IN_RE,
|
|
38
|
+
OP_SEQ_INDEX,
|
|
39
|
+
OP_SEQ_LAST_INDEX,
|
|
40
|
+
OP_SEQ_LENGTH,
|
|
41
|
+
OP_SEQ_MAP,
|
|
42
|
+
OP_SEQ_MAPI,
|
|
43
|
+
OP_SEQ_NTH,
|
|
44
|
+
OP_SEQ_NTH_I,
|
|
45
|
+
OP_SEQ_NTH_U,
|
|
46
|
+
OP_SEQ_POWER,
|
|
47
|
+
OP_SEQ_PREFIX,
|
|
48
|
+
OP_SEQ_REPLACE,
|
|
49
|
+
OP_SEQ_REPLACE_ALL,
|
|
50
|
+
OP_SEQ_SKOLEM,
|
|
51
|
+
OP_SEQ_SUFFIX,
|
|
52
|
+
OP_SEQ_TO_RE,
|
|
53
|
+
OP_SEQ_UNIT,
|
|
54
|
+
OP_STRING_CONST,
|
|
55
|
+
OP_SLT,
|
|
56
|
+
OP_STRING_FROM_CODE,
|
|
57
|
+
OP_STRING_IS_DIGIT,
|
|
58
|
+
OP_STRING_ITOS,
|
|
59
|
+
OP_STRING_LE,
|
|
60
|
+
OP_STRING_LT,
|
|
61
|
+
OP_STRING_SBVTOS,
|
|
62
|
+
OP_STRING_STOI,
|
|
63
|
+
OP_STRING_TO_CODE,
|
|
64
|
+
OP_STRING_UBVTOS,
|
|
65
|
+
OP_SUB,
|
|
66
|
+
OP_UBV2INT,
|
|
67
|
+
SORT_BOOL,
|
|
68
|
+
} from "./ast";
|
|
69
|
+
import { mkBvApp } from "./bv-decl-plugin";
|
|
70
|
+
import { getCompositeHash } from "./hash";
|
|
71
|
+
import { ObjMap } from "./hashtable";
|
|
72
|
+
import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
73
|
+
import type { Rewrite } from "./rewriter-tpl";
|
|
74
|
+
import {
|
|
75
|
+
getConcat,
|
|
76
|
+
getConcatUnits,
|
|
77
|
+
isBinaryApp,
|
|
78
|
+
isEmptySeq,
|
|
79
|
+
mkConcatOf,
|
|
80
|
+
mkEmptySeq,
|
|
81
|
+
mkSeqApp,
|
|
82
|
+
} from "./seq-decl-plugin";
|
|
83
|
+
import { type BoolRewriter, ReRewriter } from "./seq-re-rewriter";
|
|
84
|
+
|
|
85
|
+
const BR_REWRITE1 = 1;
|
|
86
|
+
const BR_REWRITE2 = 2;
|
|
87
|
+
const BR_REWRITE3 = 3;
|
|
88
|
+
const BR_REWRITE_FULL = 4;
|
|
89
|
+
const MAX_POWER_EXPANSION = 2n;
|
|
90
|
+
const UINT_MAX = 0xffffffffn;
|
|
91
|
+
|
|
92
|
+
const SHORTER = 0;
|
|
93
|
+
const LONGER = 1;
|
|
94
|
+
const SAME_LENGTH = 2;
|
|
95
|
+
const UNKNOWN_LENGTH = 3;
|
|
96
|
+
|
|
97
|
+
const SIGN_ZERO = 0;
|
|
98
|
+
const SIGN_POS = 1;
|
|
99
|
+
const SIGN_NEG = 2;
|
|
100
|
+
|
|
101
|
+
const NON_LIFTING_OPS = new Set([
|
|
102
|
+
OP_SEQ_EMPTY,
|
|
103
|
+
OP_RE_EMPTY_SET,
|
|
104
|
+
OP_RE_FULL_SEQ_SET,
|
|
105
|
+
OP_RE_FULL_CHAR_SET,
|
|
106
|
+
OP_RE_OF_PRED,
|
|
107
|
+
OP_SEQ_SKOLEM,
|
|
108
|
+
OP_SEQ_NTH,
|
|
109
|
+
OP_SEQ_NTH_I,
|
|
110
|
+
]);
|
|
111
|
+
|
|
112
|
+
export type Result = number | Rewrite | undefined;
|
|
113
|
+
|
|
114
|
+
export interface SeqPair {
|
|
115
|
+
left: number[];
|
|
116
|
+
right: number[];
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
export interface EqPair {
|
|
120
|
+
left: number;
|
|
121
|
+
right: number;
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
interface MinLength {
|
|
125
|
+
isBounded: boolean;
|
|
126
|
+
length: number;
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
const rewrite = (expr: number, depth: number): Rewrite => ({ expr, depth });
|
|
130
|
+
|
|
131
|
+
const isUnsigned = (value: bigint) => value >= 0n && value <= UINT_MAX;
|
|
132
|
+
|
|
133
|
+
const isPrefixOf = (prefix: readonly number[], chars: readonly number[]) =>
|
|
134
|
+
prefix.length <= chars.length && prefix.every((code, index) => code === chars[index]);
|
|
135
|
+
|
|
136
|
+
const isSuffixOf = (suffix: readonly number[], chars: readonly number[]) =>
|
|
137
|
+
suffix.length <= chars.length &&
|
|
138
|
+
suffix.every((code, index) => code === chars[chars.length - suffix.length + index]);
|
|
139
|
+
|
|
140
|
+
const isMatchAt = (chars: readonly number[], other: readonly number[], index: number) =>
|
|
141
|
+
other.every((code, inner) => chars[index + inner] === code);
|
|
142
|
+
|
|
143
|
+
const getIndexOf = (chars: readonly number[], other: readonly number[], offset: number) => {
|
|
144
|
+
if (offset <= chars.length && other.length === 0) return offset;
|
|
145
|
+
if (offset === chars.length || other.length + offset > chars.length) return -1;
|
|
146
|
+
for (let index = offset; index <= chars.length - other.length; index++)
|
|
147
|
+
if (isMatchAt(chars, other, index)) return index;
|
|
148
|
+
return -1;
|
|
149
|
+
};
|
|
150
|
+
|
|
151
|
+
const getLastIndexOf = (chars: readonly number[], other: readonly number[]) => {
|
|
152
|
+
if (other.length === 0) return chars.length;
|
|
153
|
+
if (other.length > chars.length) return -1;
|
|
154
|
+
for (let last = chars.length - other.length; last >= 0; last--)
|
|
155
|
+
if (isMatchAt(chars, other, last)) return last;
|
|
156
|
+
return -1;
|
|
157
|
+
};
|
|
158
|
+
|
|
159
|
+
const isContaining = (chars: readonly number[], other: readonly number[]) =>
|
|
160
|
+
other.length <= chars.length && getIndexOf(chars, other, 0) !== -1;
|
|
161
|
+
|
|
162
|
+
const getReplaced = (
|
|
163
|
+
chars: readonly number[],
|
|
164
|
+
source: readonly number[],
|
|
165
|
+
target: readonly number[],
|
|
166
|
+
) => {
|
|
167
|
+
if (chars.length < source.length) return [...chars];
|
|
168
|
+
if (source.length === 0) return [...target, ...chars];
|
|
169
|
+
const index = getIndexOf(chars, source, 0);
|
|
170
|
+
return index === -1
|
|
171
|
+
? [...chars]
|
|
172
|
+
: [...chars.slice(0, index), ...target, ...chars.slice(index + source.length)];
|
|
173
|
+
};
|
|
174
|
+
|
|
175
|
+
const getExtract = (chars: readonly number[], offset: number, length: number) =>
|
|
176
|
+
chars.slice(offset, Math.min(offset + length, chars.length));
|
|
177
|
+
|
|
178
|
+
const getCodes = (text: string) => [...text].map((char) => char.codePointAt(0)!);
|
|
179
|
+
|
|
180
|
+
const isDigit = (code: number) => code >= 48 && code <= 57;
|
|
181
|
+
|
|
182
|
+
const getCount = (bag: Map<number, number>, key: number) => bag.get(key) ?? 0;
|
|
183
|
+
|
|
184
|
+
const isSameBag = (first: Map<number, number>, second: Map<number, number>) =>
|
|
185
|
+
first.size === second.size && [...first].every(([key, count]) => second.get(key) === count);
|
|
186
|
+
|
|
187
|
+
export class SeqRewriter {
|
|
188
|
+
readonly re: ReRewriter;
|
|
189
|
+
|
|
190
|
+
constructor(
|
|
191
|
+
private manager: AstManager,
|
|
192
|
+
private isCoalescingChars = true,
|
|
193
|
+
bool?: BoolRewriter,
|
|
194
|
+
) {
|
|
195
|
+
this.re = new ReRewriter(manager, this, bool);
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
release() {
|
|
199
|
+
this.re.release();
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
private isOp(expr: number, op: number) {
|
|
203
|
+
return this.manager.getOp(expr) === op;
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
private getArg(expr: number, index: number) {
|
|
207
|
+
return this.manager.getArg(expr, index);
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
private getInt(expr: number) {
|
|
211
|
+
return this.manager.getNumeral(expr);
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
private mkInt(value: bigint | number) {
|
|
215
|
+
return this.manager.mkNumeral(BigInt(value));
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
private mkArith(op: number, args: number[]) {
|
|
219
|
+
return this.manager.mkApp(op, args, this.manager.sorts[args[0]]);
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
private mkAdd(first: number, second: number) {
|
|
223
|
+
return this.mkArith(OP_ADD, [first, second]);
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
private mkAddOf(args: number[]) {
|
|
227
|
+
return args.length === 1 && this.manager.kinds[args[0]] === KIND_APP
|
|
228
|
+
? args[0]
|
|
229
|
+
: this.mkArith(OP_ADD, args);
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
private mkSub(first: number, second: number) {
|
|
233
|
+
return this.mkArith(OP_SUB, [first, second]);
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
private mkMul(first: number, second: number) {
|
|
237
|
+
return this.mkArith(OP_MUL, [first, second]);
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
private mkCompare(op: number, first: number, second: number) {
|
|
241
|
+
return this.manager.mkApp(op, [first, second], SORT_BOOL);
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
private mkLe(first: number, second: number) {
|
|
245
|
+
return this.mkCompare(OP_LE, first, second);
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
private mkGe(first: number, second: number) {
|
|
249
|
+
return this.mkCompare(OP_GE, first, second);
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
private mkLt(first: number, second: number) {
|
|
253
|
+
return this.mkCompare(OP_LT, first, second);
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
private mkEq(first: number, second: number) {
|
|
257
|
+
return this.mkCompare(OP_EQ, first, second);
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
private mkNot(arg: number) {
|
|
261
|
+
return this.manager.mkApp(OP_NOT, [arg], SORT_BOOL);
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
private mkIte(condition: number, thenExpr: number, elseExpr: number) {
|
|
265
|
+
return this.manager.mkApp(
|
|
266
|
+
OP_ITE,
|
|
267
|
+
[condition, thenExpr, elseExpr],
|
|
268
|
+
this.manager.sorts[thenExpr],
|
|
269
|
+
);
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
private mkBool(value: boolean) {
|
|
273
|
+
return value ? this.manager.trueExpr : this.manager.falseExpr;
|
|
274
|
+
}
|
|
275
|
+
|
|
276
|
+
private mkSeq(op: number, args: number[]) {
|
|
277
|
+
return mkSeqApp(this.manager, op, args);
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
private mkConcat(first: number, second: number) {
|
|
281
|
+
return this.mkSeq(OP_SEQ_CONCAT, [first, second]);
|
|
282
|
+
}
|
|
283
|
+
|
|
284
|
+
private mkConcatOf(args: readonly number[], sort: number) {
|
|
285
|
+
return mkConcatOf(this.manager, args, sort);
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
private mkEmpty(sort: number) {
|
|
289
|
+
return mkEmptySeq(this.manager, sort);
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
private mkLength(arg: number) {
|
|
293
|
+
return this.mkSeq(OP_SEQ_LENGTH, [arg]);
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
private mkSubstr(seq: number, offset: number, length: number) {
|
|
297
|
+
return this.mkSeq(OP_SEQ_EXTRACT, [seq, offset, length]);
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
private mkIsEmpty(arg: number) {
|
|
301
|
+
return this.mkEq(arg, this.mkEmpty(this.manager.sorts[arg]));
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
private mkUnit(code: number) {
|
|
305
|
+
return this.mkSeq(OP_SEQ_UNIT, [this.manager.mkChar(code)]);
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
private isUnit(expr: number) {
|
|
309
|
+
return this.isOp(expr, OP_SEQ_UNIT);
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
private isEmpty(expr: number) {
|
|
313
|
+
return isEmptySeq(this.manager, expr);
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
private isConcat2(expr: number) {
|
|
317
|
+
return isBinaryApp(this.manager, expr, OP_SEQ_CONCAT);
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
private isApp(expr: number, op: number, numArgs: number) {
|
|
321
|
+
return this.isOp(expr, op) && this.manager.getNumArgs(expr) === numArgs;
|
|
322
|
+
}
|
|
323
|
+
|
|
324
|
+
private isValue(expr: number) {
|
|
325
|
+
return this.manager.isValue(expr);
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
private areDistinct(first: number, second: number) {
|
|
329
|
+
return this.manager.areDistinct(first, second);
|
|
330
|
+
}
|
|
331
|
+
|
|
332
|
+
private zero() {
|
|
333
|
+
return this.mkInt(0);
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
private minusOne() {
|
|
337
|
+
return this.mkInt(-1);
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
mkAppCore(decl: number, args: number[]): Result {
|
|
341
|
+
const funcDecl = this.manager.funcDecls[decl];
|
|
342
|
+
if (funcDecl.family === FAMILY_CHAR) return this.mkCharAppCore(funcDecl.op, args);
|
|
343
|
+
const op = funcDecl.op;
|
|
344
|
+
if (op === OP_STRING_CONST)
|
|
345
|
+
return this.isCoalescingChars
|
|
346
|
+
? undefined
|
|
347
|
+
: this.mkConcatOf(
|
|
348
|
+
this.manager
|
|
349
|
+
.getString(this.manager.mkApp(decl, [], funcDecl.range))!
|
|
350
|
+
.map((code) => this.mkUnit(code)),
|
|
351
|
+
funcDecl.range,
|
|
352
|
+
);
|
|
353
|
+
const result = this.mkSeqAppCore(decl, op, args);
|
|
354
|
+
if (result !== undefined || NON_LIFTING_OPS.has(op)) return result;
|
|
355
|
+
return this.liftItesThrottled(decl, args);
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
private mkSeqAppCore(decl: number, op: number, args: number[]): Result {
|
|
359
|
+
switch (op) {
|
|
360
|
+
case OP_SEQ_UNIT: {
|
|
361
|
+
const code = this.manager.getChar(args[0]);
|
|
362
|
+
return code === -1 || !this.isCoalescingChars ? undefined : this.manager.mkString([code]);
|
|
363
|
+
}
|
|
364
|
+
case OP_SEQ_CONCAT:
|
|
365
|
+
return args.length === 1 ? args[0] : this.mkSeqConcat(args[0], args[1]);
|
|
366
|
+
case OP_SEQ_LENGTH:
|
|
367
|
+
return this.mkSeqLength(args[0]);
|
|
368
|
+
case OP_SEQ_POWER:
|
|
369
|
+
return this.mkSeqPower(args[0], args[1]);
|
|
370
|
+
case OP_SEQ_EXTRACT:
|
|
371
|
+
return this.mkSeqExtract(args[0], args[1], args[2]);
|
|
372
|
+
case OP_SEQ_CONTAINS:
|
|
373
|
+
return this.mkSeqContains(args[0], args[1]);
|
|
374
|
+
case OP_SEQ_AT:
|
|
375
|
+
return this.mkSeqAt(args[0], args[1]);
|
|
376
|
+
case OP_SEQ_NTH:
|
|
377
|
+
return this.mkSeqNth(args[0], args[1]);
|
|
378
|
+
case OP_SEQ_NTH_I:
|
|
379
|
+
return this.mkSeqNthI(args[0], args[1]);
|
|
380
|
+
case OP_SEQ_PREFIX:
|
|
381
|
+
return this.mkSeqPrefix(args[0], args[1]);
|
|
382
|
+
case OP_SEQ_SUFFIX:
|
|
383
|
+
return this.mkSeqSuffix(args[0], args[1]);
|
|
384
|
+
case OP_SEQ_INDEX:
|
|
385
|
+
return args.length === 2
|
|
386
|
+
? rewrite(this.mkSeq(OP_SEQ_INDEX, [args[0], args[1], this.zero()]), BR_REWRITE1)
|
|
387
|
+
: this.mkSeqIndex(args[0], args[1], args[2]);
|
|
388
|
+
case OP_SEQ_LAST_INDEX:
|
|
389
|
+
return this.mkSeqLastIndex(args[0], args[1]);
|
|
390
|
+
case OP_SEQ_REPLACE:
|
|
391
|
+
return this.mkSeqReplace(args[0], args[1], args[2]);
|
|
392
|
+
case OP_SEQ_REPLACE_ALL:
|
|
393
|
+
return this.mkSeqReplaceAll(args[0], args[1], args[2]);
|
|
394
|
+
case OP_SEQ_MAP:
|
|
395
|
+
return this.mkSeqMap(args[0], args[1]);
|
|
396
|
+
case OP_SEQ_MAPI:
|
|
397
|
+
return this.mkSeqMapi(args[0], args[1], args[2]);
|
|
398
|
+
case OP_SEQ_FOLDL:
|
|
399
|
+
return this.mkSeqFoldl(args[0], args[1], args[2]);
|
|
400
|
+
case OP_SEQ_FOLDLI:
|
|
401
|
+
return this.mkSeqFoldli(args[0], args[1], args[2], args[3]);
|
|
402
|
+
case OP_STRING_LE:
|
|
403
|
+
return rewrite(this.mkNot(this.mkSeq(OP_STRING_LT, [args[1], args[0]])), BR_REWRITE2);
|
|
404
|
+
case OP_STRING_LT:
|
|
405
|
+
return this.mkStrLt(args[0], args[1]);
|
|
406
|
+
case OP_STRING_FROM_CODE:
|
|
407
|
+
return this.mkStrFromCode(args[0]);
|
|
408
|
+
case OP_STRING_TO_CODE:
|
|
409
|
+
return this.mkStrToCode(args[0]);
|
|
410
|
+
case OP_STRING_IS_DIGIT:
|
|
411
|
+
return this.mkStrIsDigit(args[0]);
|
|
412
|
+
case OP_STRING_ITOS:
|
|
413
|
+
return this.mkStrItos(args[0]);
|
|
414
|
+
case OP_STRING_STOI:
|
|
415
|
+
return this.mkStrStoi(args[0]);
|
|
416
|
+
case OP_STRING_UBVTOS:
|
|
417
|
+
return this.mkStrUbv2s(args[0]);
|
|
418
|
+
case OP_STRING_SBVTOS:
|
|
419
|
+
return this.mkStrSbv2s(args[0]);
|
|
420
|
+
default:
|
|
421
|
+
return this.re.mkAppCore(decl, op, args);
|
|
422
|
+
}
|
|
423
|
+
}
|
|
424
|
+
|
|
425
|
+
private mkCharAppCore(op: number, args: number[]): Result {
|
|
426
|
+
const manager = this.manager;
|
|
427
|
+
switch (op) {
|
|
428
|
+
case OP_CHAR_LE: {
|
|
429
|
+
const first = manager.getChar(args[0]);
|
|
430
|
+
if (first === 0) return manager.trueExpr;
|
|
431
|
+
const second = manager.getChar(args[1]);
|
|
432
|
+
if (second === -1) return undefined;
|
|
433
|
+
if (first > 0) return this.mkBool(first <= second);
|
|
434
|
+
return second === this.manager.maxChar ? manager.trueExpr : undefined;
|
|
435
|
+
}
|
|
436
|
+
case OP_CHAR_TO_INT: {
|
|
437
|
+
const code = manager.getChar(args[0]);
|
|
438
|
+
return code === -1 ? undefined : this.mkInt(code);
|
|
439
|
+
}
|
|
440
|
+
case OP_CHAR_FROM_BV: {
|
|
441
|
+
if (!manager.isBvNumeral(args[0])) return undefined;
|
|
442
|
+
const value = manager.getBvNumeralValue(args[0]);
|
|
443
|
+
return value <= BigInt(this.manager.maxChar) ? manager.mkChar(Number(value)) : undefined;
|
|
444
|
+
}
|
|
445
|
+
case OP_CHAR_IS_DIGIT: {
|
|
446
|
+
const code = manager.getChar(args[0]);
|
|
447
|
+
return code === -1 ? undefined : this.mkBool(isDigit(code));
|
|
448
|
+
}
|
|
449
|
+
default:
|
|
450
|
+
return undefined;
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
private liftItesThrottled(decl: number, args: number[]): Result {
|
|
455
|
+
const manager = this.manager;
|
|
456
|
+
const getDepth = (expr: number) =>
|
|
457
|
+
manager.kinds[expr] === KIND_VAR ? 1 : manager.depths[expr];
|
|
458
|
+
const range = manager.funcDecls[decl].range;
|
|
459
|
+
for (let index = 0; index < args.length; index++) {
|
|
460
|
+
const arg = args[index];
|
|
461
|
+
if (!this.isOp(arg, OP_ITE)) continue;
|
|
462
|
+
if (manager.isReSort(range) && manager.isSeqSort(manager.sorts[arg])) continue;
|
|
463
|
+
const thenExpr = this.getArg(arg, 1);
|
|
464
|
+
const elseExpr = this.getArg(arg, 2);
|
|
465
|
+
if (
|
|
466
|
+
getDepth(thenExpr) > 2 &&
|
|
467
|
+
manager.getRefCount(thenExpr) !== 1 &&
|
|
468
|
+
getDepth(elseExpr) > 2 &&
|
|
469
|
+
manager.getRefCount(elseExpr) !== 1
|
|
470
|
+
)
|
|
471
|
+
continue;
|
|
472
|
+
const newArgs = [...args];
|
|
473
|
+
newArgs[index] = thenExpr;
|
|
474
|
+
const first = manager.mkApp(decl, [...newArgs], range);
|
|
475
|
+
newArgs[index] = elseExpr;
|
|
476
|
+
const second = manager.mkApp(decl, newArgs, range);
|
|
477
|
+
return rewrite(this.mkIte(this.getArg(arg, 0), first, second), BR_REWRITE2);
|
|
478
|
+
}
|
|
479
|
+
return undefined;
|
|
480
|
+
}
|
|
481
|
+
|
|
482
|
+
mkSeqConcat(first: number, second: number): Result {
|
|
483
|
+
const manager = this.manager;
|
|
484
|
+
const firstChars = this.isCoalescingChars ? manager.getString(first) : undefined;
|
|
485
|
+
const secondChars = this.isCoalescingChars ? manager.getString(second) : undefined;
|
|
486
|
+
if (
|
|
487
|
+
(firstChars === undefined || secondChars === undefined) &&
|
|
488
|
+
!this.isOp(first, OP_SEQ_CONCAT) &&
|
|
489
|
+
!this.isEmpty(first) &&
|
|
490
|
+
!this.isEmpty(second) &&
|
|
491
|
+
!(
|
|
492
|
+
firstChars !== undefined &&
|
|
493
|
+
this.isConcat2(second) &&
|
|
494
|
+
manager.getString(this.getArg(second, 0)) !== undefined
|
|
495
|
+
)
|
|
496
|
+
)
|
|
497
|
+
return undefined;
|
|
498
|
+
if (firstChars !== undefined && secondChars !== undefined)
|
|
499
|
+
return manager.mkString([...firstChars, ...secondChars]);
|
|
500
|
+
const elements: number[] = [];
|
|
501
|
+
const todo = [second, first];
|
|
502
|
+
while (todo.length > 0) {
|
|
503
|
+
const expr = todo.pop()!;
|
|
504
|
+
if (this.isConcat2(expr)) {
|
|
505
|
+
todo.push(this.getArg(expr, 1), this.getArg(expr, 0));
|
|
506
|
+
continue;
|
|
507
|
+
}
|
|
508
|
+
if (!this.isEmpty(expr)) elements.push(expr);
|
|
509
|
+
}
|
|
510
|
+
if (elements.length === 0) return this.mkEmpty(manager.sorts[first]);
|
|
511
|
+
const coalesced: number[] = [];
|
|
512
|
+
for (const element of elements) {
|
|
513
|
+
const previous = coalesced.length > 0 ? manager.getString(coalesced.at(-1)!) : undefined;
|
|
514
|
+
const chars = manager.getString(element);
|
|
515
|
+
if (this.isCoalescingChars && previous !== undefined && chars !== undefined)
|
|
516
|
+
coalesced[coalesced.length - 1] = manager.mkString([...previous, ...chars]);
|
|
517
|
+
else coalesced.push(element);
|
|
518
|
+
}
|
|
519
|
+
return coalesced
|
|
520
|
+
.slice(0, -1)
|
|
521
|
+
.reduceRight((tail, element) => this.mkConcat(element, tail), coalesced.at(-1)!);
|
|
522
|
+
}
|
|
523
|
+
|
|
524
|
+
private mkSeqLength(seq: number): Result {
|
|
525
|
+
const elements = getConcat(this.manager, seq, []);
|
|
526
|
+
let length = 0;
|
|
527
|
+
const unbounded: number[] = [];
|
|
528
|
+
for (const element of elements) {
|
|
529
|
+
const minLength = this.getMinLength([element]);
|
|
530
|
+
if (minLength.isBounded) length += minLength.length;
|
|
531
|
+
else unbounded.push(element);
|
|
532
|
+
}
|
|
533
|
+
if (unbounded.length === 0) return this.mkInt(length);
|
|
534
|
+
if (unbounded.length !== elements.length || unbounded.length !== 1) {
|
|
535
|
+
const lengths = unbounded.map((element) => this.mkLength(element));
|
|
536
|
+
if (length !== 0) lengths.push(this.mkInt(length));
|
|
537
|
+
return rewrite(this.mkAddOf(lengths), BR_REWRITE2);
|
|
538
|
+
}
|
|
539
|
+
if (
|
|
540
|
+
this.isApp(seq, OP_SEQ_REPLACE, 3) &&
|
|
541
|
+
this.getEqLength(this.getArg(seq, 1), this.getArg(seq, 2)) === L_TRUE
|
|
542
|
+
)
|
|
543
|
+
return rewrite(this.mkLength(this.getArg(seq, 0)), BR_REWRITE1);
|
|
544
|
+
if (this.isApp(seq, OP_SEQ_MAP, 2))
|
|
545
|
+
return rewrite(this.mkLength(this.getArg(seq, 1)), BR_REWRITE1);
|
|
546
|
+
if (this.isApp(seq, OP_SEQ_MAPI, 3))
|
|
547
|
+
return rewrite(this.mkLength(this.getArg(seq, 2)), BR_REWRITE1);
|
|
548
|
+
if (this.isApp(seq, OP_SEQ_POWER, 2)) {
|
|
549
|
+
const exponent = this.getInt(this.getArg(seq, 1));
|
|
550
|
+
if (exponent !== undefined && exponent >= 0n)
|
|
551
|
+
return rewrite(
|
|
552
|
+
this.mkMul(this.getArg(seq, 1), this.mkLength(this.getArg(seq, 0))),
|
|
553
|
+
BR_REWRITE2,
|
|
554
|
+
);
|
|
555
|
+
}
|
|
556
|
+
if (this.isApp(seq, OP_SEQ_EXTRACT, 3)) {
|
|
557
|
+
const length = this.getArg(seq, 2);
|
|
558
|
+
const lengthValue = this.getInt(length);
|
|
559
|
+
if (
|
|
560
|
+
this.getInt(this.getArg(seq, 1)) === 0n &&
|
|
561
|
+
lengthValue !== undefined &&
|
|
562
|
+
lengthValue >= 0n
|
|
563
|
+
) {
|
|
564
|
+
const sourceLength = this.mkLength(this.getArg(seq, 0));
|
|
565
|
+
return rewrite(
|
|
566
|
+
this.mkIte(this.mkLe(sourceLength, length), sourceLength, length),
|
|
567
|
+
BR_REWRITE_FULL,
|
|
568
|
+
);
|
|
569
|
+
}
|
|
570
|
+
}
|
|
571
|
+
return undefined;
|
|
572
|
+
}
|
|
573
|
+
|
|
574
|
+
private mkSeqPower(seq: number, exponent: number): Result {
|
|
575
|
+
const manager = this.manager;
|
|
576
|
+
if (this.isEmpty(seq)) return seq;
|
|
577
|
+
const count = this.getInt(exponent);
|
|
578
|
+
if (count !== undefined && count <= 0n) return this.mkEmpty(manager.sorts[seq]);
|
|
579
|
+
if (count === 1n) return seq;
|
|
580
|
+
if (this.isApp(seq, OP_SEQ_POWER, 2)) {
|
|
581
|
+
const inner = this.getInt(this.getArg(seq, 1));
|
|
582
|
+
if (count !== undefined || (inner !== undefined && inner > 0n))
|
|
583
|
+
return rewrite(
|
|
584
|
+
this.mkSeq(OP_SEQ_POWER, [
|
|
585
|
+
this.getArg(seq, 0),
|
|
586
|
+
this.mkMul(this.getArg(seq, 1), exponent),
|
|
587
|
+
]),
|
|
588
|
+
BR_REWRITE_FULL,
|
|
589
|
+
);
|
|
590
|
+
}
|
|
591
|
+
if (count === undefined || count > MAX_POWER_EXPANSION) return undefined;
|
|
592
|
+
const chars = manager.getString(seq);
|
|
593
|
+
if (chars !== undefined) {
|
|
594
|
+
if (!isUnsigned(count * BigInt(chars.length))) return undefined;
|
|
595
|
+
return manager.mkString(Array.from({ length: Number(count) }, () => chars).flat());
|
|
596
|
+
}
|
|
597
|
+
return rewrite(
|
|
598
|
+
this.mkConcatOf(
|
|
599
|
+
Array.from({ length: Number(count) }, () => seq),
|
|
600
|
+
manager.sorts[seq],
|
|
601
|
+
),
|
|
602
|
+
BR_REWRITE_FULL,
|
|
603
|
+
);
|
|
604
|
+
}
|
|
605
|
+
|
|
606
|
+
private getSign(expr: number): number | undefined {
|
|
607
|
+
const manager = this.manager;
|
|
608
|
+
if (this.isOp(expr, OP_ADD)) {
|
|
609
|
+
let sign = SIGN_ZERO;
|
|
610
|
+
for (const arg of manager.getArgs(expr)) {
|
|
611
|
+
const argSign = this.getSign(arg);
|
|
612
|
+
if (argSign === undefined) return undefined;
|
|
613
|
+
if (sign === SIGN_ZERO) sign = argSign;
|
|
614
|
+
else if (argSign !== SIGN_ZERO && argSign !== sign) return undefined;
|
|
615
|
+
}
|
|
616
|
+
return sign;
|
|
617
|
+
}
|
|
618
|
+
if (this.isOp(expr, OP_MUL)) {
|
|
619
|
+
let sign = SIGN_ZERO;
|
|
620
|
+
for (const arg of manager.getArgs(expr)) {
|
|
621
|
+
const argSign = this.getSign(arg);
|
|
622
|
+
if (argSign === undefined) return undefined;
|
|
623
|
+
if (argSign === SIGN_ZERO) return SIGN_ZERO;
|
|
624
|
+
sign = sign === SIGN_ZERO ? argSign : sign !== argSign ? SIGN_NEG : SIGN_POS;
|
|
625
|
+
}
|
|
626
|
+
return sign;
|
|
627
|
+
}
|
|
628
|
+
if (this.isOp(expr, OP_SEQ_LENGTH)) return SIGN_POS;
|
|
629
|
+
if (!manager.isNumeral(expr)) return undefined;
|
|
630
|
+
const value = manager.getRationalValue(expr);
|
|
631
|
+
return value.isPositive() ? SIGN_POS : value.isNegative() ? SIGN_NEG : SIGN_ZERO;
|
|
632
|
+
}
|
|
633
|
+
|
|
634
|
+
private getLengths(expr: number, lengths: number[], offset: { value: bigint }): boolean {
|
|
635
|
+
const manager = this.manager;
|
|
636
|
+
if (this.isOp(expr, OP_ADD))
|
|
637
|
+
return manager.getArgs(expr).every((arg) => this.getLengths(arg, lengths, offset));
|
|
638
|
+
if (this.isOp(expr, OP_SEQ_LENGTH)) {
|
|
639
|
+
lengths.push(this.getArg(expr, 0));
|
|
640
|
+
return true;
|
|
641
|
+
}
|
|
642
|
+
if (this.isApp(expr, OP_MUL, 2)) {
|
|
643
|
+
const factor = this.getInt(this.getArg(expr, 0));
|
|
644
|
+
const length = this.getArg(expr, 1);
|
|
645
|
+
if (
|
|
646
|
+
factor !== undefined &&
|
|
647
|
+
this.isOp(length, OP_SEQ_LENGTH) &&
|
|
648
|
+
factor >= 0n &&
|
|
649
|
+
factor <= 10n
|
|
650
|
+
) {
|
|
651
|
+
for (let count = 0n; count < factor; count++) lengths.push(this.getArg(length, 0));
|
|
652
|
+
return true;
|
|
653
|
+
}
|
|
654
|
+
}
|
|
655
|
+
const value = this.getInt(expr);
|
|
656
|
+
if (value === undefined) return false;
|
|
657
|
+
offset.value += value;
|
|
658
|
+
return true;
|
|
659
|
+
}
|
|
660
|
+
|
|
661
|
+
private isSuffix(seq: number, offset: number, length: number) {
|
|
662
|
+
const lengths: number[] = [];
|
|
663
|
+
const sum = { value: 0n };
|
|
664
|
+
if (!this.getLengths(length, lengths, sum)) return false;
|
|
665
|
+
const start = this.getInt(offset);
|
|
666
|
+
return start !== undefined && start > 0n && -sum.value === start && lengths.includes(seq);
|
|
667
|
+
}
|
|
668
|
+
|
|
669
|
+
private isPrefix(seq: number, offset: number, length: number) {
|
|
670
|
+
const lengths: number[] = [];
|
|
671
|
+
const sum = { value: 0n };
|
|
672
|
+
return (
|
|
673
|
+
this.getLengths(length, lengths, sum) &&
|
|
674
|
+
sum.value < 0n &&
|
|
675
|
+
this.getInt(offset) === 0n &&
|
|
676
|
+
lengths.length === 1 &&
|
|
677
|
+
lengths[0] === seq
|
|
678
|
+
);
|
|
679
|
+
}
|
|
680
|
+
|
|
681
|
+
private mkLen(offset: bigint, seqs: number[]) {
|
|
682
|
+
return seqs.reduce((sum, seq) => this.mkAdd(sum, this.mkLength(seq)), this.mkInt(offset));
|
|
683
|
+
}
|
|
684
|
+
|
|
685
|
+
private removeFirst(values: number[], value: number) {
|
|
686
|
+
const index = values.indexOf(value);
|
|
687
|
+
if (index === -1) return false;
|
|
688
|
+
values.splice(index, 1);
|
|
689
|
+
return true;
|
|
690
|
+
}
|
|
691
|
+
|
|
692
|
+
private extractPopSuffix(units: number[], offset: number, length: number) {
|
|
693
|
+
const start = this.getInt(offset);
|
|
694
|
+
const count = this.getInt(length);
|
|
695
|
+
if (units.length === 0 || start === undefined || count === undefined) return undefined;
|
|
696
|
+
if (!(BigInt(this.getMinLength(units).length) >= start + count && start >= 0n && count >= 0n))
|
|
697
|
+
return undefined;
|
|
698
|
+
let index = 0;
|
|
699
|
+
let total = 0n;
|
|
700
|
+
for (; index < units.length && total < start + count; index++)
|
|
701
|
+
total += BigInt(this.getMinLength([units[index]]).length);
|
|
702
|
+
if (index >= units.length) return undefined;
|
|
703
|
+
const prefix = this.mkConcatOf(units.slice(0, index), this.manager.sorts[units[0]]);
|
|
704
|
+
return this.mkSubstr(prefix, offset, length);
|
|
705
|
+
}
|
|
706
|
+
|
|
707
|
+
private extractPushOffset(units: number[], offset: number, length: number) {
|
|
708
|
+
const lengths: number[] = [];
|
|
709
|
+
const sum = { value: 0n };
|
|
710
|
+
if (!this.getLengths(offset, lengths, sum) || sum.value < 0n) return undefined;
|
|
711
|
+
let index = 0;
|
|
712
|
+
for (; index < units.length; index++) {
|
|
713
|
+
const unit = units[index];
|
|
714
|
+
if (this.removeFirst(lengths, unit)) continue;
|
|
715
|
+
if (this.isUnit(unit) && sum.value > 0n) sum.value -= 1n;
|
|
716
|
+
else break;
|
|
717
|
+
}
|
|
718
|
+
if (index === 0) return undefined;
|
|
719
|
+
const rest = this.mkConcatOf(units.slice(index), this.manager.sorts[units[0]]);
|
|
720
|
+
return this.mkSubstr(rest, this.mkLen(sum.value, lengths), length);
|
|
721
|
+
}
|
|
722
|
+
|
|
723
|
+
private extractPushLength(units: number[], offset: number, length: number) {
|
|
724
|
+
const lengths: number[] = [];
|
|
725
|
+
const sum = { value: 0n };
|
|
726
|
+
if (
|
|
727
|
+
units.length === 0 ||
|
|
728
|
+
this.getInt(offset) !== 0n ||
|
|
729
|
+
!this.getLengths(length, lengths, sum) ||
|
|
730
|
+
sum.value < 0n
|
|
731
|
+
)
|
|
732
|
+
return undefined;
|
|
733
|
+
let index = 0;
|
|
734
|
+
for (; index < units.length; index++) {
|
|
735
|
+
const unit = units[index];
|
|
736
|
+
if (this.removeFirst(lengths, unit)) continue;
|
|
737
|
+
if (this.isUnit(unit) && sum.value > 0n) sum.value -= 1n;
|
|
738
|
+
else break;
|
|
739
|
+
}
|
|
740
|
+
const sort = this.manager.sorts[units[0]];
|
|
741
|
+
if (index === units.length) return this.mkConcatOf(units, sort);
|
|
742
|
+
if (index === 0) return undefined;
|
|
743
|
+
const rest = this.mkConcatOf(units.slice(index), sort);
|
|
744
|
+
const extract = this.mkSubstr(rest, offset, this.mkLen(sum.value, lengths));
|
|
745
|
+
return this.mkConcatOf([...units.slice(0, index), extract], sort);
|
|
746
|
+
}
|
|
747
|
+
|
|
748
|
+
private mkSeqExtract(seq: number, offset: number, length: number): Result {
|
|
749
|
+
const manager = this.manager;
|
|
750
|
+
const chars = manager.getString(seq);
|
|
751
|
+
const start = this.getInt(offset);
|
|
752
|
+
const count = this.getInt(length);
|
|
753
|
+
const sort = manager.sorts[seq];
|
|
754
|
+
if (this.getSign(length) === SIGN_NEG) return this.mkEmpty(sort);
|
|
755
|
+
if ((start !== undefined && start < 0n) || (count !== undefined && count <= 0n))
|
|
756
|
+
return this.mkEmpty(sort);
|
|
757
|
+
if (start !== undefined && chars !== undefined && start >= BigInt(chars.length))
|
|
758
|
+
return this.mkEmpty(sort);
|
|
759
|
+
if (start !== undefined) {
|
|
760
|
+
const maxLength = this.getMaxLength(seq);
|
|
761
|
+
if (maxLength.isBounded && maxLength.length <= start) return this.mkEmpty(sort);
|
|
762
|
+
}
|
|
763
|
+
if (this.isOp(offset, OP_MUL)) {
|
|
764
|
+
let hasBaseLength = false;
|
|
765
|
+
let isOtherFactorAtLeastOne = true;
|
|
766
|
+
const todo = [offset];
|
|
767
|
+
const visited = new Set<number>();
|
|
768
|
+
while (todo.length > 0) {
|
|
769
|
+
const arg = todo.pop()!;
|
|
770
|
+
if (visited.has(arg)) continue;
|
|
771
|
+
visited.add(arg);
|
|
772
|
+
if (this.isOp(arg, OP_MUL)) todo.push(...manager.getArgs(arg));
|
|
773
|
+
else if (this.isOp(arg, OP_SEQ_LENGTH) && this.getArg(arg, 0) === seq) hasBaseLength = true;
|
|
774
|
+
else {
|
|
775
|
+
const factor = manager.isNumeral(arg) ? manager.getRationalValue(arg) : undefined;
|
|
776
|
+
if (factor === undefined || factor.num < factor.den) {
|
|
777
|
+
isOtherFactorAtLeastOne = false;
|
|
778
|
+
break;
|
|
779
|
+
}
|
|
780
|
+
}
|
|
781
|
+
}
|
|
782
|
+
if (hasBaseLength && isOtherFactorAtLeastOne) return this.mkEmpty(sort);
|
|
783
|
+
}
|
|
784
|
+
const position = start !== undefined && isUnsigned(start) ? start : undefined;
|
|
785
|
+
const size = count !== undefined && isUnsigned(count) ? count : undefined;
|
|
786
|
+
if (size === 1n) return rewrite(this.mkSeq(OP_SEQ_AT, [seq, offset]), BR_REWRITE1);
|
|
787
|
+
if (position !== undefined && size !== undefined && chars !== undefined)
|
|
788
|
+
return manager.mkString(
|
|
789
|
+
position + size >= BigInt(chars.length)
|
|
790
|
+
? chars.slice(Number(position))
|
|
791
|
+
: getExtract(chars, Number(position), Number(size)),
|
|
792
|
+
);
|
|
793
|
+
const units = getConcatUnits(manager, seq, []);
|
|
794
|
+
if (units.length === 0) return this.mkEmpty(sort);
|
|
795
|
+
const popped = this.extractPopSuffix(units, offset, length);
|
|
796
|
+
if (popped !== undefined) return rewrite(popped, BR_REWRITE1);
|
|
797
|
+
const pushedOffset = this.extractPushOffset(units, offset, length);
|
|
798
|
+
if (pushedOffset !== undefined) return rewrite(pushedOffset, BR_REWRITE3);
|
|
799
|
+
const pushedLength = this.extractPushLength(units, offset, length);
|
|
800
|
+
if (pushedLength !== undefined) return rewrite(pushedLength, BR_REWRITE3);
|
|
801
|
+
const isExtract = this.isApp(seq, OP_SEQ_EXTRACT, 3);
|
|
802
|
+
const inner = isExtract ? this.getArg(seq, 0) : -1;
|
|
803
|
+
const innerOffset = isExtract ? this.getArg(seq, 1) : -1;
|
|
804
|
+
const innerLength = isExtract ? this.getArg(seq, 2) : -1;
|
|
805
|
+
if (
|
|
806
|
+
isExtract &&
|
|
807
|
+
this.isSuffix(inner, innerOffset, innerLength) &&
|
|
808
|
+
this.isSuffix(seq, offset, length)
|
|
809
|
+
) {
|
|
810
|
+
const newOffset = this.mkAdd(innerOffset, offset);
|
|
811
|
+
return rewrite(this.mkSubstr(inner, newOffset, this.mkSub(innerLength, offset)), BR_REWRITE3);
|
|
812
|
+
}
|
|
813
|
+
const innerStart = isExtract ? this.getInt(innerOffset) : undefined;
|
|
814
|
+
const innerCount = isExtract ? this.getInt(innerLength) : undefined;
|
|
815
|
+
if (
|
|
816
|
+
innerStart !== undefined &&
|
|
817
|
+
isUnsigned(innerStart) &&
|
|
818
|
+
innerCount !== undefined &&
|
|
819
|
+
isUnsigned(innerCount) &&
|
|
820
|
+
position !== undefined &&
|
|
821
|
+
size !== undefined
|
|
822
|
+
) {
|
|
823
|
+
if (innerStart === 0n && innerCount >= position + size)
|
|
824
|
+
return rewrite(this.mkSubstr(inner, offset, length), BR_REWRITE1);
|
|
825
|
+
if (position <= innerCount) {
|
|
826
|
+
const newCount = innerCount - position < size ? innerCount - position : size;
|
|
827
|
+
const newStart = this.mkInt(innerStart + position);
|
|
828
|
+
return rewrite(this.mkSubstr(inner, newStart, this.mkInt(newCount)), BR_REWRITE1);
|
|
829
|
+
}
|
|
830
|
+
}
|
|
831
|
+
if (
|
|
832
|
+
isExtract &&
|
|
833
|
+
this.isPrefix(inner, innerOffset, innerLength) &&
|
|
834
|
+
this.isPrefix(seq, offset, length)
|
|
835
|
+
) {
|
|
836
|
+
const seqLength = this.mkLength(seq);
|
|
837
|
+
return rewrite(
|
|
838
|
+
this.mkSubstr(inner, offset, this.mkSub(innerLength, this.mkSub(seqLength, length))),
|
|
839
|
+
BR_REWRITE3,
|
|
840
|
+
);
|
|
841
|
+
}
|
|
842
|
+
if (
|
|
843
|
+
isExtract &&
|
|
844
|
+
this.isPrefix(seq, offset, length) &&
|
|
845
|
+
this.isSuffix(inner, innerOffset, innerLength)
|
|
846
|
+
) {
|
|
847
|
+
const difference = this.mkSub(length, this.mkLength(seq));
|
|
848
|
+
const suffixLength = this.mkSub(this.mkLength(inner), innerOffset);
|
|
849
|
+
return rewrite(
|
|
850
|
+
this.mkSubstr(inner, innerOffset, this.mkAdd(suffixLength, difference)),
|
|
851
|
+
BR_REWRITE3,
|
|
852
|
+
);
|
|
853
|
+
}
|
|
854
|
+
if (
|
|
855
|
+
isExtract &&
|
|
856
|
+
start === 0n &&
|
|
857
|
+
this.isOp(length, OP_SEQ_LENGTH) &&
|
|
858
|
+
this.getArg(length, 0) === inner
|
|
859
|
+
)
|
|
860
|
+
return seq;
|
|
861
|
+
if (isExtract && start === 0n && length === innerLength) return seq;
|
|
862
|
+
if (
|
|
863
|
+
isExtract &&
|
|
864
|
+
this.isSuffix(seq, offset, length) &&
|
|
865
|
+
manager.isNumeral(innerLength) &&
|
|
866
|
+
manager.isNumeral(innerOffset)
|
|
867
|
+
) {
|
|
868
|
+
const newOffset = this.mkAdd(offset, innerOffset);
|
|
869
|
+
return rewrite(this.mkSubstr(inner, newOffset, this.mkSub(innerLength, offset)), BR_REWRITE2);
|
|
870
|
+
}
|
|
871
|
+
if (position === undefined) return undefined;
|
|
872
|
+
let unitCount = 0;
|
|
873
|
+
while (unitCount < units.length && this.isUnit(units[unitCount]) && unitCount < position)
|
|
874
|
+
unitCount++;
|
|
875
|
+
if (unitCount === 0 && position > 0n) return undefined;
|
|
876
|
+
if (position === 0n && units.every((unit) => this.isUnit(unit))) {
|
|
877
|
+
let result = this.mkEmpty(sort);
|
|
878
|
+
for (let index = 1; index <= units.length; index++) {
|
|
879
|
+
const condition = this.mkGe(length, this.mkInt(index));
|
|
880
|
+
result = this.mkIte(condition, this.mkConcatOf(units.slice(0, index), sort), result);
|
|
881
|
+
}
|
|
882
|
+
return rewrite(result, BR_REWRITE_FULL);
|
|
883
|
+
}
|
|
884
|
+
if (position === 0n && size === undefined) return undefined;
|
|
885
|
+
if (unitCount === units.length) return this.mkEmpty(sort);
|
|
886
|
+
if (size !== undefined && position === BigInt(unitCount)) {
|
|
887
|
+
let index = unitCount;
|
|
888
|
+
while (index < units.length && this.isUnit(units[index]) && BigInt(index - unitCount) < size)
|
|
889
|
+
index++;
|
|
890
|
+
if (BigInt(index - unitCount) === size)
|
|
891
|
+
return this.mkConcatOf(units.slice(unitCount, index), sort);
|
|
892
|
+
if (index === units.length)
|
|
893
|
+
return this.mkConcatOf(units.slice(unitCount), manager.sorts[units[0]]);
|
|
894
|
+
}
|
|
895
|
+
if (unitCount === 0) return undefined;
|
|
896
|
+
const newOffset = this.mkSub(offset, this.mkInt(unitCount));
|
|
897
|
+
const rest = this.mkConcatOf(units.slice(unitCount), manager.sorts[units[0]]);
|
|
898
|
+
return rewrite(this.mkSubstr(rest, newOffset, length), BR_REWRITE3);
|
|
899
|
+
}
|
|
900
|
+
|
|
901
|
+
private isUnitDistinct(first: number, second: number) {
|
|
902
|
+
return this.isUnit(first) && this.isUnit(second) && this.areDistinct(first, second);
|
|
903
|
+
}
|
|
904
|
+
|
|
905
|
+
private isNotContainingSuffix(first: number, second: number) {
|
|
906
|
+
if (this.isUnitDistinct(first, second)) return true;
|
|
907
|
+
const firstChars = this.manager.getString(first);
|
|
908
|
+
const secondChars = this.manager.getString(second);
|
|
909
|
+
if (firstChars === undefined || secondChars === undefined) return false;
|
|
910
|
+
for (let index = 1; index <= firstChars.length; index++)
|
|
911
|
+
if (isSuffixOf(firstChars.slice(0, index), secondChars)) return false;
|
|
912
|
+
return true;
|
|
913
|
+
}
|
|
914
|
+
|
|
915
|
+
private isNotContainingPrefix(first: number, second: number) {
|
|
916
|
+
if (this.isUnitDistinct(first, second)) return true;
|
|
917
|
+
const firstChars = this.manager.getString(first);
|
|
918
|
+
const secondChars = this.manager.getString(second);
|
|
919
|
+
if (firstChars === undefined || secondChars === undefined) return false;
|
|
920
|
+
for (let index = 0; index < firstChars.length; index++)
|
|
921
|
+
if (isSuffixOf(firstChars.slice(index), secondChars)) return false;
|
|
922
|
+
return true;
|
|
923
|
+
}
|
|
924
|
+
|
|
925
|
+
private mkSeqContains(seq: number, other: number): Result {
|
|
926
|
+
const manager = this.manager;
|
|
927
|
+
const seqChars = manager.getString(seq);
|
|
928
|
+
const otherChars = manager.getString(other);
|
|
929
|
+
if (seqChars !== undefined && otherChars !== undefined)
|
|
930
|
+
return this.mkBool(isContaining(seqChars, otherChars));
|
|
931
|
+
if (this.isApp(other, OP_SEQ_EXTRACT, 3) && this.getArg(other, 0) === seq)
|
|
932
|
+
return manager.trueExpr;
|
|
933
|
+
const seqUnits = getConcatUnits(manager, seq, []);
|
|
934
|
+
const otherUnits = getConcatUnits(manager, other, []);
|
|
935
|
+
if (otherUnits.length === 0) return manager.trueExpr;
|
|
936
|
+
if (seqUnits.length === 0) return rewrite(this.mkIsEmpty(other), BR_REWRITE2);
|
|
937
|
+
const maxLength = this.getMaxLength(seq);
|
|
938
|
+
if (maxLength.isBounded && maxLength.length <= 1n) {
|
|
939
|
+
const isEmpty = this.mkIsEmpty(other);
|
|
940
|
+
return rewrite(
|
|
941
|
+
manager.mkApp(OP_OR, [isEmpty, this.mkEq(seq, other)], SORT_BOOL),
|
|
942
|
+
BR_REWRITE2,
|
|
943
|
+
);
|
|
944
|
+
}
|
|
945
|
+
for (let index = 0; otherUnits.length + index <= seqUnits.length; index++)
|
|
946
|
+
if (otherUnits.every((unit, inner) => seqUnits[inner + index] === unit))
|
|
947
|
+
return manager.trueExpr;
|
|
948
|
+
if (
|
|
949
|
+
otherUnits.every((unit) => this.isValue(unit)) &&
|
|
950
|
+
seqUnits.every((unit) => this.isValue(unit))
|
|
951
|
+
)
|
|
952
|
+
return manager.falseExpr;
|
|
953
|
+
const seqMinLength = this.getMinLength(seqUnits);
|
|
954
|
+
if (seqMinLength.isBounded && this.getMinLength(otherUnits).length > seqMinLength.length)
|
|
955
|
+
return manager.falseExpr;
|
|
956
|
+
let start = 0;
|
|
957
|
+
let end = seqUnits.length;
|
|
958
|
+
const first = otherUnits[0];
|
|
959
|
+
const last = otherUnits.at(-1)!;
|
|
960
|
+
while (start < seqUnits.length && this.isNotContainingPrefix(seqUnits[start], first)) start++;
|
|
961
|
+
while (end > start && this.isNotContainingSuffix(seqUnits[end - 1], last)) end--;
|
|
962
|
+
if (start === end) return rewrite(this.mkIsEmpty(other), BR_REWRITE2);
|
|
963
|
+
if (start > 0 || end < seqUnits.length) {
|
|
964
|
+
const middle = this.mkConcatOf(seqUnits.slice(start, end), manager.sorts[seq]);
|
|
965
|
+
return rewrite(this.mkSeq(OP_SEQ_CONTAINS, [middle, other]), BR_REWRITE2);
|
|
966
|
+
}
|
|
967
|
+
if (
|
|
968
|
+
otherUnits.every((unit) => this.isUnit(unit)) &&
|
|
969
|
+
seqUnits.every((unit) => this.isUnit(unit))
|
|
970
|
+
) {
|
|
971
|
+
const disjuncts: number[] = [];
|
|
972
|
+
for (let index = 0; index + otherUnits.length <= seqUnits.length; index++)
|
|
973
|
+
disjuncts.push(
|
|
974
|
+
manager.mkAnd(otherUnits.map((unit, inner) => this.mkEq(seqUnits[index + inner], unit))),
|
|
975
|
+
);
|
|
976
|
+
return rewrite(manager.mkOr(disjuncts), BR_REWRITE_FULL);
|
|
977
|
+
}
|
|
978
|
+
if (otherUnits.length === 1 && this.isUnit(otherUnits[0]) && seqUnits.length > 1)
|
|
979
|
+
return rewrite(
|
|
980
|
+
manager.mkOr(seqUnits.map((unit) => this.mkSeq(OP_SEQ_CONTAINS, [unit, otherUnits[0]]))),
|
|
981
|
+
BR_REWRITE_FULL,
|
|
982
|
+
);
|
|
983
|
+
if (this.isUnit(other) && this.isValue(other)) {
|
|
984
|
+
const reduced = this.reduceByChar(seq, other, 4);
|
|
985
|
+
if (reduced !== undefined)
|
|
986
|
+
return rewrite(this.mkSeq(OP_SEQ_CONTAINS, [reduced, other]), BR_REWRITE1);
|
|
987
|
+
}
|
|
988
|
+
return undefined;
|
|
989
|
+
}
|
|
990
|
+
|
|
991
|
+
private reduceByChar(expr: number, char: number, depth: number): number | undefined {
|
|
992
|
+
const manager = this.manager;
|
|
993
|
+
if (this.isApp(expr, OP_SEQ_REPLACE, 3)) {
|
|
994
|
+
const [source, from, to] = manager.getArgs(expr);
|
|
995
|
+
if (
|
|
996
|
+
this.isUnit(from) &&
|
|
997
|
+
this.isValue(from) &&
|
|
998
|
+
this.isUnit(to) &&
|
|
999
|
+
this.isValue(to) &&
|
|
1000
|
+
char !== from &&
|
|
1001
|
+
char !== to
|
|
1002
|
+
)
|
|
1003
|
+
return depth > 0 ? (this.reduceByChar(source, char, depth - 1) ?? source) : source;
|
|
1004
|
+
}
|
|
1005
|
+
if (depth > 0 && this.isOp(expr, OP_SEQ_CONCAT)) {
|
|
1006
|
+
let isReduced = false;
|
|
1007
|
+
const args = manager.getArgs(expr).map((arg) => {
|
|
1008
|
+
const reduced = this.reduceByChar(arg, char, depth - 1);
|
|
1009
|
+
if (reduced === undefined) return arg;
|
|
1010
|
+
isReduced = true;
|
|
1011
|
+
return reduced;
|
|
1012
|
+
});
|
|
1013
|
+
return isReduced ? this.mkConcatOf(args, manager.sorts[args[0]]) : undefined;
|
|
1014
|
+
}
|
|
1015
|
+
if (depth > 0 && this.isApp(expr, OP_SEQ_EXTRACT, 3)) {
|
|
1016
|
+
const reduced = this.reduceByChar(this.getArg(expr, 0), char, depth - 1);
|
|
1017
|
+
if (reduced !== undefined)
|
|
1018
|
+
return this.mkSubstr(reduced, this.getArg(expr, 1), this.getArg(expr, 2));
|
|
1019
|
+
}
|
|
1020
|
+
return undefined;
|
|
1021
|
+
}
|
|
1022
|
+
|
|
1023
|
+
private mkSeqAt(seq: number, index: number): Result {
|
|
1024
|
+
const manager = this.manager;
|
|
1025
|
+
const sort = manager.sorts[seq];
|
|
1026
|
+
if (this.isApp(seq, OP_SEQ_EXTRACT, 3)) {
|
|
1027
|
+
const length = this.getInt(this.getArg(seq, 2));
|
|
1028
|
+
const position = this.getInt(index);
|
|
1029
|
+
if (
|
|
1030
|
+
this.getInt(this.getArg(seq, 1)) === 0n &&
|
|
1031
|
+
length !== undefined &&
|
|
1032
|
+
position !== undefined &&
|
|
1033
|
+
position < length
|
|
1034
|
+
)
|
|
1035
|
+
return rewrite(this.mkSeq(OP_SEQ_AT, [this.getArg(seq, 0), index]), BR_REWRITE1);
|
|
1036
|
+
}
|
|
1037
|
+
const lengths: number[] = [];
|
|
1038
|
+
const offset = { value: 0n };
|
|
1039
|
+
if (!this.getLengths(index, lengths, offset)) return undefined;
|
|
1040
|
+
if (lengths.length === 0 && offset.value < 0n) return this.mkEmpty(sort);
|
|
1041
|
+
if (lengths.length === 0 && this.isApp(seq, OP_SEQ_AT, 2))
|
|
1042
|
+
return offset.value > 0n ? this.mkEmpty(sort) : seq;
|
|
1043
|
+
const units = getConcatUnits(manager, seq, []);
|
|
1044
|
+
if (units.length === 0) return this.mkEmpty(sort);
|
|
1045
|
+
let count = 0;
|
|
1046
|
+
for (; count < units.length; count++) {
|
|
1047
|
+
const unit = units[count];
|
|
1048
|
+
if (lengths.includes(unit) && offset.value >= 0n) this.removeFirst(lengths, unit);
|
|
1049
|
+
else if (this.isUnit(unit) && offset.value === 0n && lengths.length === 0)
|
|
1050
|
+
return rewrite(unit, BR_REWRITE1);
|
|
1051
|
+
else if (this.isUnit(unit) && offset.value > 0n) offset.value -= 1n;
|
|
1052
|
+
else break;
|
|
1053
|
+
}
|
|
1054
|
+
if (count === 0) return undefined;
|
|
1055
|
+
if (count === units.length) return this.mkEmpty(sort);
|
|
1056
|
+
const position = lengths.reduce(
|
|
1057
|
+
(sum, length) => this.mkAdd(sum, this.mkLength(length)),
|
|
1058
|
+
this.mkInt(offset.value),
|
|
1059
|
+
);
|
|
1060
|
+
const rest = this.mkConcatOf(units.slice(count), sort);
|
|
1061
|
+
return rewrite(this.mkSeq(OP_SEQ_AT, [rest, position]), BR_REWRITE2);
|
|
1062
|
+
}
|
|
1063
|
+
|
|
1064
|
+
private mkSeqNth(seq: number, index: number): Result {
|
|
1065
|
+
const manager = this.manager;
|
|
1066
|
+
const position = this.getInt(index);
|
|
1067
|
+
if (this.isUnit(seq) && position === 0n) return this.getArg(seq, 0);
|
|
1068
|
+
if (this.isApp(seq, OP_SEQ_EXTRACT, 3)) {
|
|
1069
|
+
const source = this.getArg(seq, 0);
|
|
1070
|
+
const start = this.getInt(this.getArg(seq, 1));
|
|
1071
|
+
if (start !== undefined && start > 0n) {
|
|
1072
|
+
const lengths: number[] = [];
|
|
1073
|
+
const sum = { value: 0n };
|
|
1074
|
+
if (
|
|
1075
|
+
this.getLengths(this.getArg(seq, 2), lengths, sum) &&
|
|
1076
|
+
start === -sum.value &&
|
|
1077
|
+
lengths.length === 1 &&
|
|
1078
|
+
lengths[0] === source
|
|
1079
|
+
) {
|
|
1080
|
+
const shift = this.mkInt(start);
|
|
1081
|
+
const inRange = this.mkSeq(OP_SEQ_NTH_I, [source, this.mkAdd(index, shift)]);
|
|
1082
|
+
const pastEmpty = this.mkSeq(OP_SEQ_NTH_U, [this.mkEmpty(manager.sorts[source]), index]);
|
|
1083
|
+
const outOfRange = this.mkSeq(OP_SEQ_NTH_U, [seq, index]);
|
|
1084
|
+
const shifted = this.mkAdd(shift, index);
|
|
1085
|
+
let result = this.mkIte(this.mkLt(shifted, this.mkLength(source)), inRange, outOfRange);
|
|
1086
|
+
result = this.mkIte(this.mkGe(shift, this.mkLength(source)), pastEmpty, result);
|
|
1087
|
+
result = this.mkIte(this.mkLt(index, this.zero()), outOfRange, result);
|
|
1088
|
+
return rewrite(result, BR_REWRITE_FULL);
|
|
1089
|
+
}
|
|
1090
|
+
}
|
|
1091
|
+
}
|
|
1092
|
+
const minLength = this.getMinLength([seq]);
|
|
1093
|
+
if (minLength.isBounded && position !== undefined)
|
|
1094
|
+
return rewrite(
|
|
1095
|
+
this.mkSeq(
|
|
1096
|
+
position >= 0n && position < BigInt(minLength.length) ? OP_SEQ_NTH_I : OP_SEQ_NTH_U,
|
|
1097
|
+
[seq, index],
|
|
1098
|
+
),
|
|
1099
|
+
BR_REWRITE_FULL,
|
|
1100
|
+
);
|
|
1101
|
+
const length = this.mkLength(seq);
|
|
1102
|
+
const isNonNegative = this.mkGe(index, this.zero());
|
|
1103
|
+
const isInRange = this.mkNot(this.mkLe(length, index));
|
|
1104
|
+
const guard = manager.mkApp(OP_AND, [isNonNegative, isInRange], SORT_BOOL);
|
|
1105
|
+
const inRange = this.mkSeq(OP_SEQ_NTH_I, [seq, index]);
|
|
1106
|
+
return rewrite(
|
|
1107
|
+
this.mkIte(guard, inRange, this.mkSeq(OP_SEQ_NTH_U, [seq, index])),
|
|
1108
|
+
BR_REWRITE_FULL,
|
|
1109
|
+
);
|
|
1110
|
+
}
|
|
1111
|
+
|
|
1112
|
+
private mkSeqNthI(seq: number, index: number): Result {
|
|
1113
|
+
const manager = this.manager;
|
|
1114
|
+
const offsetValue = this.getInt(index);
|
|
1115
|
+
if (offsetValue === undefined || !isUnsigned(offsetValue)) return undefined;
|
|
1116
|
+
const offset = Number(offsetValue);
|
|
1117
|
+
if (offset === 0 && this.isApp(seq, OP_SEQ_AT, 2) && this.getInt(this.getArg(seq, 1)) === 0n)
|
|
1118
|
+
return rewrite(
|
|
1119
|
+
this.mkSeq(OP_SEQ_NTH_I, [this.getArg(seq, 0), this.getArg(seq, 1)]),
|
|
1120
|
+
BR_REWRITE1,
|
|
1121
|
+
);
|
|
1122
|
+
if (this.isApp(seq, OP_SEQ_MAP, 2)) {
|
|
1123
|
+
const element = this.mkSeq(OP_SEQ_NTH_I, [this.getArg(seq, 1), index]);
|
|
1124
|
+
return rewrite(mkArrayApp(manager, OP_SELECT, [this.getArg(seq, 0), element]), BR_REWRITE1);
|
|
1125
|
+
}
|
|
1126
|
+
let position = 0;
|
|
1127
|
+
for (const unit of getConcatUnits(manager, seq, [])) {
|
|
1128
|
+
if (this.isUnit(unit)) {
|
|
1129
|
+
if (offset === position) return this.getArg(unit, 0);
|
|
1130
|
+
position++;
|
|
1131
|
+
continue;
|
|
1132
|
+
}
|
|
1133
|
+
if (!this.isOp(unit, OP_ITE)) break;
|
|
1134
|
+
const minLength = this.getMinLength([unit]);
|
|
1135
|
+
if (!minLength.isBounded) break;
|
|
1136
|
+
if (position + minLength.length <= offset) {
|
|
1137
|
+
position += minLength.length;
|
|
1138
|
+
continue;
|
|
1139
|
+
}
|
|
1140
|
+
const innerIndex = this.mkInt(offset - position);
|
|
1141
|
+
const thenExpr = this.mkSeq(OP_SEQ_NTH_I, [this.getArg(unit, 1), innerIndex]);
|
|
1142
|
+
const elseExpr = this.mkSeq(OP_SEQ_NTH_I, [this.getArg(unit, 2), innerIndex]);
|
|
1143
|
+
return rewrite(this.mkIte(this.getArg(unit, 0), thenExpr, elseExpr), BR_REWRITE2);
|
|
1144
|
+
}
|
|
1145
|
+
return undefined;
|
|
1146
|
+
}
|
|
1147
|
+
|
|
1148
|
+
private compareLengths(first: number[], second: number[]) {
|
|
1149
|
+
let firstUnits = 0;
|
|
1150
|
+
let secondUnits = 0;
|
|
1151
|
+
const counts = new Map<number, number>();
|
|
1152
|
+
let hasForeign = false;
|
|
1153
|
+
for (const element of first)
|
|
1154
|
+
if (this.isUnit(element)) firstUnits++;
|
|
1155
|
+
else counts.set(element, getCount(counts, element) + 1);
|
|
1156
|
+
for (const element of second) {
|
|
1157
|
+
if (this.isUnit(element)) secondUnits++;
|
|
1158
|
+
else if (counts.has(element)) {
|
|
1159
|
+
const count = getCount(counts, element) - 1;
|
|
1160
|
+
if (count === 0) counts.delete(element);
|
|
1161
|
+
else counts.set(element, count);
|
|
1162
|
+
} else hasForeign = true;
|
|
1163
|
+
}
|
|
1164
|
+
if (firstUnits > secondUnits && !hasForeign) return LONGER;
|
|
1165
|
+
if (firstUnits === secondUnits && !hasForeign && counts.size === 0) return SAME_LENGTH;
|
|
1166
|
+
if (secondUnits > firstUnits && counts.size === 0) return SHORTER;
|
|
1167
|
+
return UNKNOWN_LENGTH;
|
|
1168
|
+
}
|
|
1169
|
+
|
|
1170
|
+
private mkSeqLastIndex(seq: number, other: number): Result {
|
|
1171
|
+
const manager = this.manager;
|
|
1172
|
+
const seqChars = manager.getString(seq);
|
|
1173
|
+
const otherChars = manager.getString(other);
|
|
1174
|
+
if (seqChars !== undefined && otherChars !== undefined)
|
|
1175
|
+
return this.mkInt(getLastIndexOf(seqChars, otherChars));
|
|
1176
|
+
if (seq === other) return this.mkInt(0);
|
|
1177
|
+
if (this.isEmpty(other)) return this.mkLength(seq);
|
|
1178
|
+
const seqUnits = getConcatUnits(manager, seq, []);
|
|
1179
|
+
const otherUnits = getConcatUnits(manager, other, []);
|
|
1180
|
+
const getSuffixMatch = () => {
|
|
1181
|
+
if (seqUnits.length < otherUnits.length) return L_UNDEF;
|
|
1182
|
+
for (let index = 0; index < otherUnits.length; index++) {
|
|
1183
|
+
const seqUnit = seqUnits[seqUnits.length - index - 1];
|
|
1184
|
+
const otherUnit = otherUnits[otherUnits.length - index - 1];
|
|
1185
|
+
if (seqUnit === otherUnit) continue;
|
|
1186
|
+
return this.areDistinct(seqUnit, otherUnit) ? L_FALSE : L_UNDEF;
|
|
1187
|
+
}
|
|
1188
|
+
return L_TRUE;
|
|
1189
|
+
};
|
|
1190
|
+
switch (this.compareLengths(seqUnits, otherUnits)) {
|
|
1191
|
+
case SHORTER:
|
|
1192
|
+
return this.minusOne();
|
|
1193
|
+
case SAME_LENGTH: {
|
|
1194
|
+
const isEqual = this.mkEq(seq, other);
|
|
1195
|
+
const found = this.zero();
|
|
1196
|
+
return rewrite(this.mkIte(isEqual, found, this.minusOne()), BR_REWRITE_FULL);
|
|
1197
|
+
}
|
|
1198
|
+
case LONGER: {
|
|
1199
|
+
// Z3 subtracts these sizes as unsigned integers, so its offset wraps; this one does not.
|
|
1200
|
+
if (!otherUnits.every((unit) => this.isUnit(unit))) return undefined;
|
|
1201
|
+
let popped = 0;
|
|
1202
|
+
while (seqUnits.length >= otherUnits.length) {
|
|
1203
|
+
const match = getSuffixMatch();
|
|
1204
|
+
if (match === L_UNDEF) return undefined;
|
|
1205
|
+
if (match === L_TRUE)
|
|
1206
|
+
return rewrite(
|
|
1207
|
+
this.mkSub(this.mkLength(seq), this.mkInt(popped + otherUnits.length)),
|
|
1208
|
+
BR_REWRITE3,
|
|
1209
|
+
);
|
|
1210
|
+
if (!this.isUnit(seqUnits.pop()!)) return undefined;
|
|
1211
|
+
popped++;
|
|
1212
|
+
}
|
|
1213
|
+
return undefined;
|
|
1214
|
+
}
|
|
1215
|
+
default:
|
|
1216
|
+
return undefined;
|
|
1217
|
+
}
|
|
1218
|
+
}
|
|
1219
|
+
|
|
1220
|
+
private mkSeqIndex(seq: number, other: number, start: number): Result {
|
|
1221
|
+
const manager = this.manager;
|
|
1222
|
+
const seqChars = manager.getString(seq);
|
|
1223
|
+
const otherChars = manager.getString(other);
|
|
1224
|
+
const sort = manager.sorts[seq];
|
|
1225
|
+
const startValue = this.getInt(start);
|
|
1226
|
+
if (
|
|
1227
|
+
seqChars !== undefined &&
|
|
1228
|
+
otherChars !== undefined &&
|
|
1229
|
+
startValue !== undefined &&
|
|
1230
|
+
isUnsigned(startValue)
|
|
1231
|
+
)
|
|
1232
|
+
return this.mkInt(getIndexOf(seqChars, otherChars, Number(startValue)));
|
|
1233
|
+
if (startValue !== undefined && startValue < 0n) return this.minusOne();
|
|
1234
|
+
if (this.isEmpty(other) && startValue === 0n) return start;
|
|
1235
|
+
if (this.isEmpty(other)) {
|
|
1236
|
+
const isNonNegative = this.mkLe(this.zero(), start);
|
|
1237
|
+
const isInRange = this.mkLe(start, this.mkLength(seq));
|
|
1238
|
+
const condition = manager.mkApp(OP_AND, [isNonNegative, isInRange], SORT_BOOL);
|
|
1239
|
+
return rewrite(this.mkIte(condition, start, this.minusOne()), BR_REWRITE2);
|
|
1240
|
+
}
|
|
1241
|
+
if (this.isEmpty(seq)) {
|
|
1242
|
+
const isEmpty = this.mkIsEmpty(other);
|
|
1243
|
+
const isStart = this.mkEq(start, this.zero());
|
|
1244
|
+
const condition = manager.mkApp(OP_AND, [isStart, isEmpty], SORT_BOOL);
|
|
1245
|
+
const found = this.zero();
|
|
1246
|
+
return rewrite(this.mkIte(condition, found, this.minusOne()), BR_REWRITE2);
|
|
1247
|
+
}
|
|
1248
|
+
if (seq === other) {
|
|
1249
|
+
if (startValue !== undefined) return startValue === 0n ? this.zero() : this.minusOne();
|
|
1250
|
+
const found = this.zero();
|
|
1251
|
+
const isAtZero = this.mkEq(found, start);
|
|
1252
|
+
return rewrite(this.mkIte(isAtZero, found, this.minusOne()), BR_REWRITE2);
|
|
1253
|
+
}
|
|
1254
|
+
if (this.isApp(seq, OP_SEQ_EXTRACT, 3)) {
|
|
1255
|
+
const length = this.getInt(this.getArg(seq, 2));
|
|
1256
|
+
if (length !== undefined && startValue !== undefined && startValue > length)
|
|
1257
|
+
return this.minusOne();
|
|
1258
|
+
}
|
|
1259
|
+
const seqUnits = getConcatUnits(manager, seq, []);
|
|
1260
|
+
if (startValue !== undefined) {
|
|
1261
|
+
let remaining = startValue;
|
|
1262
|
+
let count = 0;
|
|
1263
|
+
while (remaining > 0n && count < seqUnits.length && this.isUnit(seqUnits[count])) {
|
|
1264
|
+
remaining -= 1n;
|
|
1265
|
+
count++;
|
|
1266
|
+
}
|
|
1267
|
+
if (count > 0) {
|
|
1268
|
+
const rest = this.mkConcatOf(seqUnits.slice(count), sort);
|
|
1269
|
+
const index = this.mkSeq(OP_SEQ_INDEX, [rest, other, this.mkInt(remaining)]);
|
|
1270
|
+
const isFound = this.mkGe(index, this.zero());
|
|
1271
|
+
const shifted = this.mkAdd(this.mkInt(count), index);
|
|
1272
|
+
return rewrite(this.mkIte(isFound, shifted, this.minusOne()), BR_REWRITE_FULL);
|
|
1273
|
+
}
|
|
1274
|
+
}
|
|
1275
|
+
const isZero = startValue === 0n;
|
|
1276
|
+
const otherUnits = getConcatUnits(manager, other, []);
|
|
1277
|
+
let count = 0;
|
|
1278
|
+
while (
|
|
1279
|
+
isZero &&
|
|
1280
|
+
count < seqUnits.length &&
|
|
1281
|
+
otherUnits.length > 0 &&
|
|
1282
|
+
this.isUnit(seqUnits[count]) &&
|
|
1283
|
+
this.isUnit(otherUnits[0]) &&
|
|
1284
|
+
this.areDistinct(seqUnits[count], otherUnits[0])
|
|
1285
|
+
)
|
|
1286
|
+
count++;
|
|
1287
|
+
if (count > 0) {
|
|
1288
|
+
const index = this.mkSeq(OP_SEQ_INDEX, [
|
|
1289
|
+
this.mkConcatOf(seqUnits.slice(count), sort),
|
|
1290
|
+
other,
|
|
1291
|
+
start,
|
|
1292
|
+
]);
|
|
1293
|
+
const isFound = this.mkGe(index, this.zero());
|
|
1294
|
+
const shifted = this.mkAdd(this.mkInt(count), index);
|
|
1295
|
+
return rewrite(this.mkIte(isFound, shifted, this.minusOne()), BR_REWRITE_FULL);
|
|
1296
|
+
}
|
|
1297
|
+
switch (this.compareLengths(seqUnits, otherUnits)) {
|
|
1298
|
+
case SHORTER:
|
|
1299
|
+
if (isZero) return this.minusOne();
|
|
1300
|
+
break;
|
|
1301
|
+
case SAME_LENGTH: {
|
|
1302
|
+
const isNegative = this.mkLe(start, this.minusOne());
|
|
1303
|
+
const isStart = this.mkEq(start, this.zero());
|
|
1304
|
+
const isEqual = this.mkEq(seq, other);
|
|
1305
|
+
const found = this.zero();
|
|
1306
|
+
const atStart = this.mkIte(isEqual, found, this.minusOne());
|
|
1307
|
+
const notNegative = this.mkIte(isStart, atStart, this.minusOne());
|
|
1308
|
+
return rewrite(this.mkIte(isNegative, this.minusOne(), notNegative), BR_REWRITE_FULL);
|
|
1309
|
+
}
|
|
1310
|
+
}
|
|
1311
|
+
if (isZero && seqUnits.length > 0 && this.isUnit(seqUnits[0])) {
|
|
1312
|
+
const rest = this.mkConcatOf(seqUnits.slice(1), manager.sorts[seqUnits[0]]);
|
|
1313
|
+
const index = this.mkSeq(OP_SEQ_INDEX, [rest, other, start]);
|
|
1314
|
+
const isPrefix = this.mkSeq(OP_SEQ_PREFIX, [other, seq]);
|
|
1315
|
+
const isFound = this.mkGe(index, this.zero());
|
|
1316
|
+
const shifted = this.mkAdd(this.mkInt(1), index);
|
|
1317
|
+
const notPrefix = this.mkIte(isFound, shifted, this.minusOne());
|
|
1318
|
+
return rewrite(this.mkIte(isPrefix, this.zero(), notPrefix), BR_REWRITE3);
|
|
1319
|
+
}
|
|
1320
|
+
if (this.isUnit(other) && this.isValue(other)) {
|
|
1321
|
+
const reduced = this.reduceByChar(seq, other, 4);
|
|
1322
|
+
if (reduced !== undefined)
|
|
1323
|
+
return rewrite(this.mkSeq(OP_SEQ_INDEX, [reduced, other, start]), BR_REWRITE1);
|
|
1324
|
+
}
|
|
1325
|
+
return undefined;
|
|
1326
|
+
}
|
|
1327
|
+
|
|
1328
|
+
private mkSeqReplace(seq: number, from: number, to: number): Result {
|
|
1329
|
+
const manager = this.manager;
|
|
1330
|
+
const sort = manager.sorts[seq];
|
|
1331
|
+
const seqChars = manager.getString(seq);
|
|
1332
|
+
const fromChars = manager.getString(from);
|
|
1333
|
+
const toChars = manager.getString(to);
|
|
1334
|
+
if (seqChars !== undefined && fromChars !== undefined && toChars !== undefined)
|
|
1335
|
+
return manager.mkString(getReplaced(seqChars, fromChars, toChars));
|
|
1336
|
+
if (from === to) return seq;
|
|
1337
|
+
if (seq === from) return to;
|
|
1338
|
+
if (this.isEmpty(from)) return rewrite(this.mkConcat(to, seq), BR_REWRITE1);
|
|
1339
|
+
if (this.isEmpty(seq) && this.isEmpty(to)) return seq;
|
|
1340
|
+
const elements = getConcat(manager, seq, []);
|
|
1341
|
+
if (elements.length === 0)
|
|
1342
|
+
return this.getMinLength(getConcat(manager, from, [])).length > 0 ? seq : undefined;
|
|
1343
|
+
if (elements[0] === from) {
|
|
1344
|
+
elements[0] = to;
|
|
1345
|
+
return rewrite(this.mkConcatOf(elements, sort), BR_REWRITE1);
|
|
1346
|
+
}
|
|
1347
|
+
const headChars = manager.getString(elements[0]);
|
|
1348
|
+
if (
|
|
1349
|
+
fromChars !== undefined &&
|
|
1350
|
+
toChars !== undefined &&
|
|
1351
|
+
headChars !== undefined &&
|
|
1352
|
+
isContaining(headChars, fromChars)
|
|
1353
|
+
) {
|
|
1354
|
+
elements[0] = manager.mkString(getReplaced(headChars, fromChars, toChars));
|
|
1355
|
+
return rewrite(this.mkConcatOf(elements, sort), BR_REWRITE1);
|
|
1356
|
+
}
|
|
1357
|
+
const seqUnits = getConcatUnits(manager, seq, []);
|
|
1358
|
+
const fromUnits = getConcatUnits(manager, from, []);
|
|
1359
|
+
if (fromUnits.length === 0) return rewrite(this.mkConcat(to, seq), BR_REWRITE1);
|
|
1360
|
+
const compareAt = (index: number) => {
|
|
1361
|
+
for (let inner = 0; inner < fromUnits.length && index + inner < seqUnits.length; inner++) {
|
|
1362
|
+
const fromUnit = fromUnits[inner];
|
|
1363
|
+
const seqUnit = seqUnits[index + inner];
|
|
1364
|
+
if (seqUnit === fromUnit) continue;
|
|
1365
|
+
if (!this.isUnit(fromUnit) || !this.isUnit(seqUnit)) return L_UNDEF;
|
|
1366
|
+
return this.areDistinct(seqUnit, fromUnit) ? L_FALSE : L_UNDEF;
|
|
1367
|
+
}
|
|
1368
|
+
return L_TRUE;
|
|
1369
|
+
};
|
|
1370
|
+
let index = 0;
|
|
1371
|
+
for (; index < seqUnits.length; index++) {
|
|
1372
|
+
const comparison = compareAt(index);
|
|
1373
|
+
if (comparison === L_FALSE && this.isUnit(seqUnits[index])) continue;
|
|
1374
|
+
if (comparison === L_TRUE && seqUnits.length < index + fromUnits.length) {
|
|
1375
|
+
const head = this.mkConcatOf(seqUnits.slice(0, index), sort);
|
|
1376
|
+
const tail = this.mkConcatOf(seqUnits.slice(index), sort);
|
|
1377
|
+
const isMatch = this.mkEq(tail, from);
|
|
1378
|
+
return rewrite(this.mkIte(isMatch, this.mkConcat(head, to), seq), BR_REWRITE_FULL);
|
|
1379
|
+
}
|
|
1380
|
+
if (comparison === L_TRUE)
|
|
1381
|
+
return rewrite(
|
|
1382
|
+
this.mkConcatOf(
|
|
1383
|
+
[...seqUnits.slice(0, index), to, ...seqUnits.slice(index + fromUnits.length)],
|
|
1384
|
+
sort,
|
|
1385
|
+
),
|
|
1386
|
+
BR_REWRITE_FULL,
|
|
1387
|
+
);
|
|
1388
|
+
break;
|
|
1389
|
+
}
|
|
1390
|
+
if (index === 0) return undefined;
|
|
1391
|
+
const head = this.mkConcatOf(seqUnits.slice(0, index), sort);
|
|
1392
|
+
const tail = this.mkConcatOf(seqUnits.slice(index), sort);
|
|
1393
|
+
return rewrite(
|
|
1394
|
+
this.mkConcat(head, this.mkSeq(OP_SEQ_REPLACE, [tail, from, to])),
|
|
1395
|
+
BR_REWRITE_FULL,
|
|
1396
|
+
);
|
|
1397
|
+
}
|
|
1398
|
+
|
|
1399
|
+
private getUnitValues(seq: number) {
|
|
1400
|
+
const values: number[] = [];
|
|
1401
|
+
let current = seq;
|
|
1402
|
+
while (this.isConcat2(current)) {
|
|
1403
|
+
const head = this.getArg(current, 0);
|
|
1404
|
+
if (!this.isUnit(head) || !this.isValue(this.getArg(head, 0))) return undefined;
|
|
1405
|
+
values.push(head);
|
|
1406
|
+
current = this.getArg(current, 1);
|
|
1407
|
+
}
|
|
1408
|
+
if (!this.isUnit(current) || !this.isValue(this.getArg(current, 0))) return undefined;
|
|
1409
|
+
values.push(current);
|
|
1410
|
+
return values;
|
|
1411
|
+
}
|
|
1412
|
+
|
|
1413
|
+
private mkSeqReplaceAll(seq: number, from: number, to: number): Result {
|
|
1414
|
+
const manager = this.manager;
|
|
1415
|
+
const sort = manager.sorts[seq];
|
|
1416
|
+
if (this.isEmpty(from) || from === to) return seq;
|
|
1417
|
+
if (seq === from) {
|
|
1418
|
+
const isEmpty = this.mkIsEmpty(from);
|
|
1419
|
+
return rewrite(this.mkIte(isEmpty, this.mkEmpty(sort), to), BR_REWRITE2);
|
|
1420
|
+
}
|
|
1421
|
+
if (this.isEmpty(seq) && this.isEmpty(to)) return seq;
|
|
1422
|
+
const seqChars = manager.getString(seq);
|
|
1423
|
+
const fromChars = manager.getString(from);
|
|
1424
|
+
if (seqChars !== undefined && fromChars !== undefined) {
|
|
1425
|
+
if (seqChars.length < fromChars.length) return seq;
|
|
1426
|
+
const parts: number[] = [];
|
|
1427
|
+
for (let index = 0; index < seqChars.length; index++) {
|
|
1428
|
+
if (seqChars.length >= fromChars.length + index && isMatchAt(seqChars, fromChars, index)) {
|
|
1429
|
+
parts.push(to);
|
|
1430
|
+
index += fromChars.length - 1;
|
|
1431
|
+
} else parts.push(this.mkUnit(seqChars[index]));
|
|
1432
|
+
}
|
|
1433
|
+
return rewrite(this.mkConcatOf(parts, sort), BR_REWRITE_FULL);
|
|
1434
|
+
}
|
|
1435
|
+
const seqValues = this.getUnitValues(seq);
|
|
1436
|
+
const fromValues = seqValues === undefined ? undefined : this.getUnitValues(from);
|
|
1437
|
+
if (seqValues === undefined || fromValues === undefined) return undefined;
|
|
1438
|
+
const parts: number[] = [];
|
|
1439
|
+
let index = 0;
|
|
1440
|
+
while (index + fromValues.length <= seqValues.length) {
|
|
1441
|
+
if (fromValues.every((value, inner) => value === seqValues[index + inner])) {
|
|
1442
|
+
parts.push(to);
|
|
1443
|
+
index += fromValues.length;
|
|
1444
|
+
} else parts.push(seqValues[index++]);
|
|
1445
|
+
}
|
|
1446
|
+
parts.push(...seqValues.slice(index));
|
|
1447
|
+
return rewrite(this.mkConcatOf(parts, sort), BR_REWRITE_FULL);
|
|
1448
|
+
}
|
|
1449
|
+
|
|
1450
|
+
private getArrayRangeSeqSort(array: number) {
|
|
1451
|
+
return this.manager.mkSeqSort(this.manager.getArrayRange(this.manager.sorts[array]));
|
|
1452
|
+
}
|
|
1453
|
+
|
|
1454
|
+
private mkSeqMap(map: number, seq: number): Result {
|
|
1455
|
+
if (this.isEmpty(seq)) return this.mkEmpty(this.getArrayRangeSeqSort(map));
|
|
1456
|
+
if (this.isUnit(seq))
|
|
1457
|
+
return rewrite(
|
|
1458
|
+
this.mkSeq(OP_SEQ_UNIT, [mkArrayApp(this.manager, OP_SELECT, [map, this.getArg(seq, 0)])]),
|
|
1459
|
+
BR_REWRITE2,
|
|
1460
|
+
);
|
|
1461
|
+
if (!this.isConcat2(seq)) return undefined;
|
|
1462
|
+
const first = this.mkSeq(OP_SEQ_MAP, [map, this.getArg(seq, 0)]);
|
|
1463
|
+
const second = this.mkSeq(OP_SEQ_MAP, [map, this.getArg(seq, 1)]);
|
|
1464
|
+
return rewrite(this.mkConcat(first, second), BR_REWRITE2);
|
|
1465
|
+
}
|
|
1466
|
+
|
|
1467
|
+
private mkSeqMapi(map: number, index: number, seq: number): Result {
|
|
1468
|
+
if (this.isEmpty(seq)) return this.mkEmpty(this.getArrayRangeSeqSort(map));
|
|
1469
|
+
if (this.isUnit(seq))
|
|
1470
|
+
return rewrite(
|
|
1471
|
+
this.mkSeq(OP_SEQ_UNIT, [
|
|
1472
|
+
mkArrayApp(this.manager, OP_SELECT, [map, index, this.getArg(seq, 0)]),
|
|
1473
|
+
]),
|
|
1474
|
+
BR_REWRITE2,
|
|
1475
|
+
);
|
|
1476
|
+
if (!this.isConcat2(seq)) return undefined;
|
|
1477
|
+
const head = this.getArg(seq, 0);
|
|
1478
|
+
const next = this.mkAdd(index, this.mkLength(head));
|
|
1479
|
+
const first = this.mkSeq(OP_SEQ_MAPI, [map, index, head]);
|
|
1480
|
+
const second = this.mkSeq(OP_SEQ_MAPI, [map, next, this.getArg(seq, 1)]);
|
|
1481
|
+
return rewrite(this.mkConcat(first, second), BR_REWRITE2);
|
|
1482
|
+
}
|
|
1483
|
+
|
|
1484
|
+
private mkSeqFoldl(fold: number, initial: number, seq: number): Result {
|
|
1485
|
+
if (this.isEmpty(seq)) return initial;
|
|
1486
|
+
if (this.isUnit(seq))
|
|
1487
|
+
return rewrite(
|
|
1488
|
+
mkArrayApp(this.manager, OP_SELECT, [fold, initial, this.getArg(seq, 0)]),
|
|
1489
|
+
BR_REWRITE1,
|
|
1490
|
+
);
|
|
1491
|
+
if (!this.isConcat2(seq)) return undefined;
|
|
1492
|
+
const first = this.mkSeq(OP_SEQ_FOLDL, [fold, initial, this.getArg(seq, 0)]);
|
|
1493
|
+
return rewrite(this.mkSeq(OP_SEQ_FOLDL, [fold, first, this.getArg(seq, 1)]), BR_REWRITE3);
|
|
1494
|
+
}
|
|
1495
|
+
|
|
1496
|
+
private mkSeqFoldli(fold: number, index: number, initial: number, seq: number): Result {
|
|
1497
|
+
if (this.isEmpty(seq)) return initial;
|
|
1498
|
+
if (this.isUnit(seq))
|
|
1499
|
+
return rewrite(
|
|
1500
|
+
mkArrayApp(this.manager, OP_SELECT, [fold, index, initial, this.getArg(seq, 0)]),
|
|
1501
|
+
BR_REWRITE1,
|
|
1502
|
+
);
|
|
1503
|
+
if (!this.isConcat2(seq)) return undefined;
|
|
1504
|
+
const head = this.getArg(seq, 0);
|
|
1505
|
+
const next = this.mkAdd(index, this.mkLength(head));
|
|
1506
|
+
const first = this.mkSeq(OP_SEQ_FOLDLI, [fold, index, initial, head]);
|
|
1507
|
+
return rewrite(
|
|
1508
|
+
this.mkSeq(OP_SEQ_FOLDLI, [fold, next, first, this.getArg(seq, 1)]),
|
|
1509
|
+
BR_REWRITE3,
|
|
1510
|
+
);
|
|
1511
|
+
}
|
|
1512
|
+
|
|
1513
|
+
private mkSeqPrefix(first: number, second: number): Result {
|
|
1514
|
+
const manager = this.manager;
|
|
1515
|
+
const sort = manager.sorts[first];
|
|
1516
|
+
const firstChars = manager.getString(first);
|
|
1517
|
+
const secondChars = manager.getString(second);
|
|
1518
|
+
if (firstChars !== undefined && secondChars !== undefined)
|
|
1519
|
+
return this.mkBool(isPrefixOf(firstChars, secondChars));
|
|
1520
|
+
if (this.isEmpty(first)) return manager.trueExpr;
|
|
1521
|
+
const getLeftmost = (expr: number) => {
|
|
1522
|
+
let current = expr;
|
|
1523
|
+
while (this.isConcat2(current)) current = this.getArg(current, 0);
|
|
1524
|
+
return current;
|
|
1525
|
+
};
|
|
1526
|
+
const firstHead = getLeftmost(first);
|
|
1527
|
+
const secondHead = getLeftmost(second);
|
|
1528
|
+
const firstHeadChars = manager.getString(firstHead);
|
|
1529
|
+
const secondHeadChars = manager.getString(secondHead);
|
|
1530
|
+
if (firstHead !== secondHead && firstHeadChars !== undefined && secondHeadChars !== undefined) {
|
|
1531
|
+
if (firstHeadChars.length <= secondHeadChars.length) {
|
|
1532
|
+
if (!isPrefixOf(firstHeadChars, secondHeadChars)) return manager.falseExpr;
|
|
1533
|
+
if (first === firstHead) return manager.trueExpr;
|
|
1534
|
+
const firstElements = getConcat(manager, first, []);
|
|
1535
|
+
const secondElements = getConcat(manager, second, []);
|
|
1536
|
+
secondElements[0] = manager.mkString(secondHeadChars.slice(firstHeadChars.length));
|
|
1537
|
+
const firstRest = this.mkConcatOf(firstElements.slice(1), sort);
|
|
1538
|
+
const secondRest = this.mkConcatOf(secondElements, sort);
|
|
1539
|
+
return rewrite(this.mkSeq(OP_SEQ_PREFIX, [firstRest, secondRest]), BR_REWRITE_FULL);
|
|
1540
|
+
}
|
|
1541
|
+
if (!isPrefixOf(secondHeadChars, firstHeadChars)) return manager.falseExpr;
|
|
1542
|
+
if (second === secondHead) return manager.falseExpr;
|
|
1543
|
+
const firstElements = getConcat(manager, first, []);
|
|
1544
|
+
const secondElements = getConcat(manager, second, []);
|
|
1545
|
+
firstElements[0] = manager.mkString(firstHeadChars.slice(secondHeadChars.length));
|
|
1546
|
+
const firstRest = this.mkConcatOf(firstElements, sort);
|
|
1547
|
+
return rewrite(
|
|
1548
|
+
this.mkSeq(OP_SEQ_PREFIX, [firstRest, this.mkConcatOf(secondElements.slice(1), sort)]),
|
|
1549
|
+
BR_REWRITE_FULL,
|
|
1550
|
+
);
|
|
1551
|
+
}
|
|
1552
|
+
const firstUnits = getConcatUnits(manager, first, []);
|
|
1553
|
+
const secondUnits = getConcatUnits(manager, second, []);
|
|
1554
|
+
const eqs: number[] = [];
|
|
1555
|
+
let index = 0;
|
|
1556
|
+
for (; index < firstUnits.length && index < secondUnits.length; index++) {
|
|
1557
|
+
const firstUnit = firstUnits[index];
|
|
1558
|
+
const secondUnit = secondUnits[index];
|
|
1559
|
+
if (firstUnit === secondUnit) continue;
|
|
1560
|
+
if (this.areDistinct(firstUnit, secondUnit)) return manager.falseExpr;
|
|
1561
|
+
if (!this.isUnit(firstUnit) || !this.isUnit(secondUnit)) break;
|
|
1562
|
+
eqs.push(this.mkEq(firstUnit, secondUnit));
|
|
1563
|
+
}
|
|
1564
|
+
if (index === firstUnits.length) return rewrite(manager.mkAnd(eqs), BR_REWRITE3);
|
|
1565
|
+
if (index === secondUnits.length) {
|
|
1566
|
+
for (const unit of firstUnits.slice(index)) eqs.push(this.mkIsEmpty(unit));
|
|
1567
|
+
return rewrite(manager.mkAnd(eqs), BR_REWRITE3);
|
|
1568
|
+
}
|
|
1569
|
+
if (index > 0) {
|
|
1570
|
+
const firstRest = this.mkConcatOf(firstUnits.slice(index), sort);
|
|
1571
|
+
const secondRest = this.mkConcatOf(secondUnits.slice(index), sort);
|
|
1572
|
+
eqs.push(this.mkSeq(OP_SEQ_PREFIX, [firstRest, secondRest]));
|
|
1573
|
+
return rewrite(manager.mkAnd(eqs), BR_REWRITE3);
|
|
1574
|
+
}
|
|
1575
|
+
if (
|
|
1576
|
+
this.isApp(first, OP_SEQ_REPLACE, 3) &&
|
|
1577
|
+
this.getArg(first, 0) === this.getArg(first, 2) &&
|
|
1578
|
+
this.getArg(first, 1) === second
|
|
1579
|
+
)
|
|
1580
|
+
return this.mkSeq(OP_SEQ_PREFIX, [this.getArg(first, 0), second]);
|
|
1581
|
+
return this.mkEqByLength(first, second);
|
|
1582
|
+
}
|
|
1583
|
+
|
|
1584
|
+
private mkEqByLength(first: number, second: number): Result {
|
|
1585
|
+
const maxLength = this.getMaxLength(second);
|
|
1586
|
+
if (!maxLength.isBounded || maxLength.length > BigInt(this.getMinLength([first]).length))
|
|
1587
|
+
return undefined;
|
|
1588
|
+
return rewrite(this.mkEq(first, second), BR_REWRITE1);
|
|
1589
|
+
}
|
|
1590
|
+
|
|
1591
|
+
private mkSeqSuffix(first: number, second: number): Result {
|
|
1592
|
+
const manager = this.manager;
|
|
1593
|
+
if (first === second) return manager.trueExpr;
|
|
1594
|
+
const sort = manager.sorts[first];
|
|
1595
|
+
if (this.isEmpty(first)) return manager.trueExpr;
|
|
1596
|
+
if (this.isEmpty(second)) return rewrite(this.mkIsEmpty(first), BR_REWRITE3);
|
|
1597
|
+
const firstUnits = getConcatUnits(manager, first, []);
|
|
1598
|
+
const secondUnits = getConcatUnits(manager, second, []);
|
|
1599
|
+
const eqs: number[] = [];
|
|
1600
|
+
const firstSize = firstUnits.length;
|
|
1601
|
+
const secondSize = secondUnits.length;
|
|
1602
|
+
let index = 1;
|
|
1603
|
+
for (; index <= firstSize && index <= secondSize; index++) {
|
|
1604
|
+
const firstUnit = firstUnits[firstSize - index];
|
|
1605
|
+
const secondUnit = secondUnits[secondSize - index];
|
|
1606
|
+
if (firstUnit === secondUnit) continue;
|
|
1607
|
+
if (this.areDistinct(firstUnit, secondUnit)) return manager.falseExpr;
|
|
1608
|
+
if (!this.isUnit(firstUnit) || !this.isUnit(secondUnit)) break;
|
|
1609
|
+
eqs.push(this.mkEq(firstUnit, secondUnit));
|
|
1610
|
+
}
|
|
1611
|
+
if (index > firstSize) return rewrite(manager.mkAnd(eqs), BR_REWRITE3);
|
|
1612
|
+
if (index > secondSize) {
|
|
1613
|
+
for (let inner = index; inner <= firstSize; inner++)
|
|
1614
|
+
eqs.push(this.mkIsEmpty(firstUnits[firstSize - inner]));
|
|
1615
|
+
return rewrite(manager.mkAnd(eqs), BR_REWRITE3);
|
|
1616
|
+
}
|
|
1617
|
+
if (index > 1) {
|
|
1618
|
+
const firstRest = this.mkConcatOf(firstUnits.slice(0, firstSize - index + 1), sort);
|
|
1619
|
+
const secondRest = this.mkConcatOf(secondUnits.slice(0, secondSize - index + 1), sort);
|
|
1620
|
+
eqs.push(this.mkSeq(OP_SEQ_SUFFIX, [firstRest, secondRest]));
|
|
1621
|
+
return rewrite(manager.mkAnd(eqs), BR_REWRITE3);
|
|
1622
|
+
}
|
|
1623
|
+
if (
|
|
1624
|
+
this.isApp(first, OP_SEQ_REPLACE, 3) &&
|
|
1625
|
+
this.getArg(first, 0) === this.getArg(first, 2) &&
|
|
1626
|
+
this.getArg(first, 1) === second
|
|
1627
|
+
)
|
|
1628
|
+
return this.mkSeq(OP_SEQ_SUFFIX, [this.getArg(first, 0), second]);
|
|
1629
|
+
return this.mkEqByLength(first, second);
|
|
1630
|
+
}
|
|
1631
|
+
|
|
1632
|
+
private mkStrLt(first: number, second: number): Result {
|
|
1633
|
+
const manager = this.manager;
|
|
1634
|
+
if (this.isEmpty(second)) return manager.falseExpr;
|
|
1635
|
+
if (this.isEmpty(first)) return rewrite(this.mkNot(this.mkEq(first, second)), BR_REWRITE1);
|
|
1636
|
+
const firstChars = manager.getString(first);
|
|
1637
|
+
const secondChars = manager.getString(second);
|
|
1638
|
+
if (firstChars === undefined || secondChars === undefined) return undefined;
|
|
1639
|
+
const size = Math.min(firstChars.length, secondChars.length);
|
|
1640
|
+
for (let index = 0; index < size; index++) {
|
|
1641
|
+
if (firstChars[index] < secondChars[index]) return manager.trueExpr;
|
|
1642
|
+
if (firstChars[index] > secondChars[index]) return manager.falseExpr;
|
|
1643
|
+
}
|
|
1644
|
+
return this.mkBool(firstChars.length < secondChars.length);
|
|
1645
|
+
}
|
|
1646
|
+
|
|
1647
|
+
private mkStrFromCode(code: number): Result {
|
|
1648
|
+
const value = this.getInt(code);
|
|
1649
|
+
if (value === undefined) return undefined;
|
|
1650
|
+
return this.manager.mkString(
|
|
1651
|
+
value < 0n || value > BigInt(this.manager.maxChar) ? [] : [Number(value)],
|
|
1652
|
+
);
|
|
1653
|
+
}
|
|
1654
|
+
|
|
1655
|
+
private mkStrToCode(seq: number): Result {
|
|
1656
|
+
const chars = this.manager.getString(seq);
|
|
1657
|
+
if (chars === undefined) return undefined;
|
|
1658
|
+
return chars.length === 1 ? this.mkInt(chars[0]) : this.minusOne();
|
|
1659
|
+
}
|
|
1660
|
+
|
|
1661
|
+
private mkStrIsDigit(seq: number): Result {
|
|
1662
|
+
const chars = this.manager.getString(seq);
|
|
1663
|
+
if (chars !== undefined) return this.mkBool(chars.length === 1 && isDigit(chars[0]));
|
|
1664
|
+
return this.isEmpty(seq) ? this.manager.falseExpr : undefined;
|
|
1665
|
+
}
|
|
1666
|
+
|
|
1667
|
+
private mkStrUbv2s(bv: number): Result {
|
|
1668
|
+
const manager = this.manager;
|
|
1669
|
+
if (!manager.isBvNumeral(bv)) return undefined;
|
|
1670
|
+
return manager.mkString(getCodes(manager.getBvNumeralValue(bv).toString()));
|
|
1671
|
+
}
|
|
1672
|
+
|
|
1673
|
+
private mkStrSbv2s(bv: number): Result {
|
|
1674
|
+
const manager = this.manager;
|
|
1675
|
+
const size = manager.getBvSize(manager.sorts[bv]);
|
|
1676
|
+
if (manager.isBvNumeral(bv)) {
|
|
1677
|
+
const modulus = 1n << BigInt(size);
|
|
1678
|
+
const value = ((manager.getBvNumeralValue(bv) % modulus) + modulus) % modulus;
|
|
1679
|
+
const signed = value >= modulus >> 1n ? value - modulus : value;
|
|
1680
|
+
return manager.mkString(getCodes(signed.toString()));
|
|
1681
|
+
}
|
|
1682
|
+
const isNegative = mkBvApp(manager, OP_SLT, [bv, manager.mkBvNumeral(0n, size)]);
|
|
1683
|
+
const minus = manager.mkString(getCodes("-"));
|
|
1684
|
+
const negated = this.mkSeq(OP_STRING_UBVTOS, [mkBvApp(manager, OP_BNEG, [bv])]);
|
|
1685
|
+
const negative = this.mkConcat(minus, negated);
|
|
1686
|
+
return rewrite(
|
|
1687
|
+
this.mkIte(isNegative, negative, this.mkSeq(OP_STRING_UBVTOS, [bv])),
|
|
1688
|
+
BR_REWRITE_FULL,
|
|
1689
|
+
);
|
|
1690
|
+
}
|
|
1691
|
+
|
|
1692
|
+
private mkStrItos(value: number): Result {
|
|
1693
|
+
const manager = this.manager;
|
|
1694
|
+
if (manager.isNumeral(value)) {
|
|
1695
|
+
const rational = manager.getRationalValue(value);
|
|
1696
|
+
return manager.mkString(
|
|
1697
|
+
rational.isInt() && !rational.isNegative() ? getCodes(rational.num.toString()) : [],
|
|
1698
|
+
);
|
|
1699
|
+
}
|
|
1700
|
+
if (!this.isOp(value, OP_STRING_STOI)) return undefined;
|
|
1701
|
+
const seq = this.getArg(value, 0);
|
|
1702
|
+
const maxLength = this.getMaxLength(seq);
|
|
1703
|
+
if (!maxLength.isBounded || maxLength.length > 1n) return undefined;
|
|
1704
|
+
const eqs = Array.from({ length: 10 }, (_, digit) =>
|
|
1705
|
+
this.mkEq(seq, manager.mkString([48 + digit])),
|
|
1706
|
+
);
|
|
1707
|
+
const isDigitString = manager.mkApp(OP_OR, eqs, SORT_BOOL);
|
|
1708
|
+
return rewrite(this.mkIte(isDigitString, seq, manager.mkString([])), BR_REWRITE2);
|
|
1709
|
+
}
|
|
1710
|
+
|
|
1711
|
+
private mkStrStoi(seq: number): Result {
|
|
1712
|
+
const manager = this.manager;
|
|
1713
|
+
const chars = manager.getString(seq);
|
|
1714
|
+
if (chars !== undefined) {
|
|
1715
|
+
if (chars.length === 0 || !chars.every(isDigit)) return this.minusOne();
|
|
1716
|
+
return this.mkInt(BigInt(String.fromCodePoint(...chars)));
|
|
1717
|
+
}
|
|
1718
|
+
if (this.isOp(seq, OP_STRING_ITOS)) {
|
|
1719
|
+
const value = this.getArg(seq, 0);
|
|
1720
|
+
return this.mkIte(this.mkGe(value, this.zero()), value, this.minusOne());
|
|
1721
|
+
}
|
|
1722
|
+
if (this.isOp(seq, OP_STRING_UBVTOS))
|
|
1723
|
+
return mkBvApp(manager, OP_UBV2INT, [this.getArg(seq, 0)]);
|
|
1724
|
+
if (this.isOp(seq, OP_ITE)) {
|
|
1725
|
+
const thenExpr = this.mkSeq(OP_STRING_STOI, [this.getArg(seq, 1)]);
|
|
1726
|
+
return rewrite(
|
|
1727
|
+
this.mkIte(
|
|
1728
|
+
this.getArg(seq, 0),
|
|
1729
|
+
thenExpr,
|
|
1730
|
+
this.mkSeq(OP_STRING_STOI, [this.getArg(seq, 2)]),
|
|
1731
|
+
),
|
|
1732
|
+
BR_REWRITE_FULL,
|
|
1733
|
+
);
|
|
1734
|
+
}
|
|
1735
|
+
if (this.isUnit(seq)) {
|
|
1736
|
+
const code = manager.getChar(this.getArg(seq, 0));
|
|
1737
|
+
if (code !== -1) return isDigit(code) ? this.mkInt(code - 48) : this.minusOne();
|
|
1738
|
+
}
|
|
1739
|
+
const units = getConcatUnits(manager, seq, []);
|
|
1740
|
+
if (units.length === 0) return this.minusOne();
|
|
1741
|
+
if (this.isUnit(units.at(-1)!)) {
|
|
1742
|
+
const tail = this.mkSeq(OP_STRING_STOI, [units.at(-1)!]);
|
|
1743
|
+
const head = this.mkConcatOf(units.slice(0, -1), manager.sorts[seq]);
|
|
1744
|
+
const headValue = this.mkSeq(OP_STRING_STOI, [head]);
|
|
1745
|
+
const isHeadValid = this.mkGe(headValue, this.zero());
|
|
1746
|
+
const combined = this.mkAdd(this.mkMul(this.mkInt(10), headValue), tail);
|
|
1747
|
+
let result = this.mkIte(isHeadValid, combined, this.minusOne());
|
|
1748
|
+
result = this.mkIte(this.mkGe(tail, this.zero()), result, tail);
|
|
1749
|
+
result = this.mkIte(this.mkIsEmpty(head), tail, result);
|
|
1750
|
+
return rewrite(result, BR_REWRITE_FULL);
|
|
1751
|
+
}
|
|
1752
|
+
if (this.isUnit(units[0]) && manager.getChar(this.getArg(units[0], 0)) === 48) {
|
|
1753
|
+
const rest = this.mkConcatOf(units.slice(1), manager.sorts[units[0]]);
|
|
1754
|
+
const isEmpty = this.mkIsEmpty(rest);
|
|
1755
|
+
const value = this.mkSeq(OP_STRING_STOI, [rest]);
|
|
1756
|
+
return rewrite(this.mkIte(isEmpty, this.zero(), value), BR_REWRITE_FULL);
|
|
1757
|
+
}
|
|
1758
|
+
return undefined;
|
|
1759
|
+
}
|
|
1760
|
+
|
|
1761
|
+
getMinLength(seqs: readonly number[]): MinLength {
|
|
1762
|
+
const manager = this.manager;
|
|
1763
|
+
const todo = [...seqs];
|
|
1764
|
+
const pending: number[] = [];
|
|
1765
|
+
const cache = new Map<number, MinLength>();
|
|
1766
|
+
let length = 0;
|
|
1767
|
+
let isBounded = true;
|
|
1768
|
+
if (seqs.length === 0) return { isBounded, length };
|
|
1769
|
+
const visit = (expr: number) => {
|
|
1770
|
+
if (cache.has(expr)) return true;
|
|
1771
|
+
if (this.isUnit(expr)) cache.set(expr, { isBounded: true, length: 1 });
|
|
1772
|
+
else if (this.isEmpty(expr)) cache.set(expr, { isBounded: true, length: 0 });
|
|
1773
|
+
else if (manager.getString(expr) !== undefined)
|
|
1774
|
+
cache.set(expr, { isBounded: true, length: manager.getString(expr)!.length });
|
|
1775
|
+
else if (this.isOp(expr, OP_SEQ_CONCAT)) {
|
|
1776
|
+
let isVisited = true;
|
|
1777
|
+
let isValid = true;
|
|
1778
|
+
let count = 0;
|
|
1779
|
+
for (const arg of manager.getArgs(expr)) {
|
|
1780
|
+
const cached = cache.get(arg);
|
|
1781
|
+
if (cached === undefined) {
|
|
1782
|
+
pending.push(arg);
|
|
1783
|
+
isVisited = false;
|
|
1784
|
+
continue;
|
|
1785
|
+
}
|
|
1786
|
+
isValid &&= cached.isBounded;
|
|
1787
|
+
count += cached.length;
|
|
1788
|
+
}
|
|
1789
|
+
if (isVisited) cache.set(expr, { isBounded: isValid, length: count });
|
|
1790
|
+
return isVisited;
|
|
1791
|
+
} else if (this.isOp(expr, OP_ITE)) {
|
|
1792
|
+
const size = pending.length;
|
|
1793
|
+
const thenLength = cache.get(this.getArg(expr, 1));
|
|
1794
|
+
const elseLength = cache.get(this.getArg(expr, 2));
|
|
1795
|
+
if (thenLength === undefined) pending.push(this.getArg(expr, 1));
|
|
1796
|
+
if (elseLength === undefined) pending.push(this.getArg(expr, 2));
|
|
1797
|
+
if (size !== pending.length) return false;
|
|
1798
|
+
cache.set(expr, {
|
|
1799
|
+
isBounded:
|
|
1800
|
+
thenLength!.isBounded &&
|
|
1801
|
+
elseLength!.isBounded &&
|
|
1802
|
+
thenLength!.length === elseLength!.length,
|
|
1803
|
+
length: Math.min(thenLength!.length, elseLength!.length),
|
|
1804
|
+
});
|
|
1805
|
+
} else cache.set(expr, { isBounded: false, length: 0 });
|
|
1806
|
+
return true;
|
|
1807
|
+
};
|
|
1808
|
+
while (todo.length > 0) {
|
|
1809
|
+
const expr = todo.pop()!;
|
|
1810
|
+
const chars = manager.getString(expr);
|
|
1811
|
+
if (this.isUnit(expr)) length++;
|
|
1812
|
+
else if (this.isEmpty(expr)) continue;
|
|
1813
|
+
else if (chars !== undefined) length += chars.length;
|
|
1814
|
+
else if (this.isOp(expr, OP_SEQ_CONCAT)) todo.push(...manager.getArgs(expr));
|
|
1815
|
+
else if (this.isOp(expr, OP_ITE)) {
|
|
1816
|
+
const thenExpr = this.getArg(expr, 1);
|
|
1817
|
+
const elseExpr = this.getArg(expr, 2);
|
|
1818
|
+
pending.push(thenExpr, elseExpr);
|
|
1819
|
+
while (pending.length > 0) if (visit(pending.at(-1)!)) pending.pop();
|
|
1820
|
+
const thenLength = cache.get(thenExpr) ?? { isBounded: false, length: 0 };
|
|
1821
|
+
const elseLength = cache.get(elseExpr) ?? { isBounded: false, length: 0 };
|
|
1822
|
+
if (
|
|
1823
|
+
!thenLength.isBounded ||
|
|
1824
|
+
!elseLength.isBounded ||
|
|
1825
|
+
thenLength.length !== elseLength.length
|
|
1826
|
+
)
|
|
1827
|
+
isBounded = false;
|
|
1828
|
+
length += Math.min(thenLength.length, elseLength.length);
|
|
1829
|
+
} else isBounded = false;
|
|
1830
|
+
}
|
|
1831
|
+
return { isBounded, length };
|
|
1832
|
+
}
|
|
1833
|
+
|
|
1834
|
+
getMaxLength(seq: number) {
|
|
1835
|
+
const manager = this.manager;
|
|
1836
|
+
const todo = [seq];
|
|
1837
|
+
let length = 0n;
|
|
1838
|
+
while (todo.length > 0) {
|
|
1839
|
+
const expr = todo.pop()!;
|
|
1840
|
+
const chars = manager.getString(expr);
|
|
1841
|
+
if (this.isUnit(expr) || this.isApp(expr, OP_SEQ_AT, 2)) length += 1n;
|
|
1842
|
+
else if (chars !== undefined) length += BigInt(chars.length);
|
|
1843
|
+
else if (
|
|
1844
|
+
this.isApp(expr, OP_SEQ_EXTRACT, 3) &&
|
|
1845
|
+
(this.getInt(this.getArg(expr, 2)) ?? -1n) >= 0n
|
|
1846
|
+
)
|
|
1847
|
+
length += this.getInt(this.getArg(expr, 2))!;
|
|
1848
|
+
else if (this.isEmpty(expr)) continue;
|
|
1849
|
+
else if (this.isOp(expr, OP_SEQ_CONCAT)) todo.push(...manager.getArgs(expr));
|
|
1850
|
+
else return { isBounded: false, length };
|
|
1851
|
+
}
|
|
1852
|
+
return { isBounded: true, length };
|
|
1853
|
+
}
|
|
1854
|
+
|
|
1855
|
+
private getEqLength(first: number, second: number) {
|
|
1856
|
+
const firstLength = this.getMinLength([first]);
|
|
1857
|
+
if (!firstLength.isBounded) return L_UNDEF;
|
|
1858
|
+
const secondLength = this.getMinLength([second]);
|
|
1859
|
+
if (!secondLength.isBounded) return L_UNDEF;
|
|
1860
|
+
return firstLength.length === secondLength.length ? L_TRUE : L_FALSE;
|
|
1861
|
+
}
|
|
1862
|
+
|
|
1863
|
+
mkBoolApp(isAnd: boolean, args: number[]): Result {
|
|
1864
|
+
const manager = this.manager;
|
|
1865
|
+
const getMembership = (expr: number) => (this.isApp(expr, OP_SEQ_IN_RE, 2) ? expr : undefined);
|
|
1866
|
+
const isMembership = (expr: number) =>
|
|
1867
|
+
getMembership(expr) !== undefined ||
|
|
1868
|
+
(this.isOp(expr, OP_NOT) && getMembership(this.getArg(expr, 0)) !== undefined);
|
|
1869
|
+
if (!args.some(isMembership)) return undefined;
|
|
1870
|
+
const getHash = (expr: number) => manager.hashes[expr];
|
|
1871
|
+
const memberships = new ObjMap<number>(getHash);
|
|
1872
|
+
const exclusions = new ObjMap<number>(getHash);
|
|
1873
|
+
const mkRe = (op: number, first: number, second: number) => this.mkSeq(op, [first, second]);
|
|
1874
|
+
let isPaired = false;
|
|
1875
|
+
const newArgs: number[] = [];
|
|
1876
|
+
for (const arg of args) {
|
|
1877
|
+
const isNegated = this.isOp(arg, OP_NOT) && this.isApp(this.getArg(arg, 0), OP_SEQ_IN_RE, 2);
|
|
1878
|
+
const membership = isNegated ? this.getArg(arg, 0) : arg;
|
|
1879
|
+
if (!this.isApp(membership, OP_SEQ_IN_RE, 2) || this.isEmpty(this.getArg(membership, 0))) {
|
|
1880
|
+
newArgs.push(arg);
|
|
1881
|
+
continue;
|
|
1882
|
+
}
|
|
1883
|
+
const seq = this.getArg(membership, 0);
|
|
1884
|
+
const regex = this.getArg(membership, 1);
|
|
1885
|
+
const same = isNegated ? exclusions : memberships;
|
|
1886
|
+
const other = isNegated ? memberships : exclusions;
|
|
1887
|
+
const existing = same.get(seq);
|
|
1888
|
+
if (existing === undefined) {
|
|
1889
|
+
same.set(seq, regex);
|
|
1890
|
+
isPaired ||= other.has(seq);
|
|
1891
|
+
continue;
|
|
1892
|
+
}
|
|
1893
|
+
same.set(seq, mkRe(isAnd !== isNegated ? OP_RE_INTERSECT : OP_RE_UNION, existing, regex));
|
|
1894
|
+
isPaired = true;
|
|
1895
|
+
}
|
|
1896
|
+
if (!isPaired) return undefined;
|
|
1897
|
+
for (const [seq, regex] of memberships) {
|
|
1898
|
+
const excluded = exclusions.get(seq);
|
|
1899
|
+
if (excluded === undefined) {
|
|
1900
|
+
newArgs.push(mkRe(OP_SEQ_IN_RE, seq, regex));
|
|
1901
|
+
continue;
|
|
1902
|
+
}
|
|
1903
|
+
const complement = this.mkSeq(OP_RE_COMPLEMENT, [excluded]);
|
|
1904
|
+
const combined = mkRe(isAnd ? OP_RE_INTERSECT : OP_RE_UNION, regex, complement);
|
|
1905
|
+
newArgs.push(mkRe(OP_SEQ_IN_RE, seq, combined));
|
|
1906
|
+
}
|
|
1907
|
+
for (const [seq, regex] of exclusions)
|
|
1908
|
+
if (!memberships.has(seq))
|
|
1909
|
+
newArgs.push(mkRe(OP_SEQ_IN_RE, seq, this.mkSeq(OP_RE_COMPLEMENT, [regex])));
|
|
1910
|
+
return rewrite(manager.mkApp(isAnd ? OP_AND : OP_OR, newArgs, SORT_BOOL), BR_REWRITE_FULL);
|
|
1911
|
+
}
|
|
1912
|
+
|
|
1913
|
+
mkEqCore(left: number, right: number): Result {
|
|
1914
|
+
const manager = this.manager;
|
|
1915
|
+
if (manager.isReSort(manager.sorts[left])) return this.re.reduceReEq(left, right);
|
|
1916
|
+
const empty = this.reduceEqEmpty(left, right);
|
|
1917
|
+
if (empty !== undefined) return rewrite(empty, BR_REWRITE_FULL);
|
|
1918
|
+
if (
|
|
1919
|
+
this.isApp(left, OP_SEQ_POWER, 2) &&
|
|
1920
|
+
this.isApp(right, OP_SEQ_POWER, 2) &&
|
|
1921
|
+
this.getArg(left, 0) === this.getArg(right, 0)
|
|
1922
|
+
) {
|
|
1923
|
+
const base = this.getArg(left, 0);
|
|
1924
|
+
const firstExponent = this.getArg(left, 1);
|
|
1925
|
+
const secondExponent = this.getArg(right, 1);
|
|
1926
|
+
const isEmpty = this.mkEq(base, this.mkEmpty(manager.sorts[base]));
|
|
1927
|
+
const isFirstNonPositive = this.mkLe(firstExponent, this.zero());
|
|
1928
|
+
const isSecondNonPositive = this.mkLe(secondExponent, this.zero());
|
|
1929
|
+
const areNonPositive = manager.mkApp(
|
|
1930
|
+
OP_AND,
|
|
1931
|
+
[isFirstNonPositive, isSecondNonPositive],
|
|
1932
|
+
SORT_BOOL,
|
|
1933
|
+
);
|
|
1934
|
+
const isFirstPositive = this.mkLt(this.zero(), firstExponent);
|
|
1935
|
+
const isSecondPositive = this.mkLt(this.zero(), secondExponent);
|
|
1936
|
+
const isEqual = this.mkEq(firstExponent, secondExponent);
|
|
1937
|
+
const arePositive = manager.mkApp(
|
|
1938
|
+
OP_AND,
|
|
1939
|
+
[isFirstPositive, isSecondPositive, isEqual],
|
|
1940
|
+
SORT_BOOL,
|
|
1941
|
+
);
|
|
1942
|
+
return rewrite(
|
|
1943
|
+
manager.mkApp(OP_OR, [isEmpty, areNonPositive, arePositive], SORT_BOOL),
|
|
1944
|
+
BR_REWRITE_FULL,
|
|
1945
|
+
);
|
|
1946
|
+
}
|
|
1947
|
+
const replaceSide = this.isOp(left, OP_SEQ_REPLACE_ALL)
|
|
1948
|
+
? left
|
|
1949
|
+
: this.isOp(right, OP_SEQ_REPLACE_ALL)
|
|
1950
|
+
? right
|
|
1951
|
+
: -1;
|
|
1952
|
+
if (replaceSide !== -1 && this.isApp(replaceSide, OP_SEQ_REPLACE_ALL, 3)) {
|
|
1953
|
+
const stringSide = replaceSide === left ? right : left;
|
|
1954
|
+
const from = manager.getString(this.getArg(replaceSide, 1));
|
|
1955
|
+
const to = manager.getString(this.getArg(replaceSide, 2));
|
|
1956
|
+
if (from?.length === 1 && to?.length === 1 && manager.getString(stringSide) !== undefined)
|
|
1957
|
+
return rewrite(
|
|
1958
|
+
this.mkSeq(OP_SEQ_IN_RE, [replaceSide, this.mkSeq(OP_SEQ_TO_RE, [stringSide])]),
|
|
1959
|
+
BR_REWRITE_FULL,
|
|
1960
|
+
);
|
|
1961
|
+
}
|
|
1962
|
+
const eqs: EqPair[] = [];
|
|
1963
|
+
const reduced = this.reduceEq(left, right, eqs);
|
|
1964
|
+
if (reduced === undefined) return manager.falseExpr;
|
|
1965
|
+
if (!reduced) return undefined;
|
|
1966
|
+
return rewrite(manager.mkAnd(eqs.map((eq) => this.mkEq(eq.left, eq.right))), BR_REWRITE3);
|
|
1967
|
+
}
|
|
1968
|
+
|
|
1969
|
+
private reduceEqEmpty(inputLeft: number, inputRight: number) {
|
|
1970
|
+
const manager = this.manager;
|
|
1971
|
+
const [swappedLeft, swappedRight] = this.isEmpty(inputRight)
|
|
1972
|
+
? [inputRight, inputLeft]
|
|
1973
|
+
: [inputLeft, inputRight];
|
|
1974
|
+
const [left, right] = this.isOp(swappedRight, OP_SEQ_LENGTH)
|
|
1975
|
+
? [swappedRight, swappedLeft]
|
|
1976
|
+
: [swappedLeft, swappedRight];
|
|
1977
|
+
if (!this.isEmpty(left)) return undefined;
|
|
1978
|
+
if (this.isApp(right, OP_SEQ_EXTRACT, 3)) {
|
|
1979
|
+
const [seq, offset, length] = manager.getArgs(right);
|
|
1980
|
+
const seqLength = this.mkLength(seq);
|
|
1981
|
+
return this.mkOrOf([
|
|
1982
|
+
() => this.mkLt(offset, this.zero()),
|
|
1983
|
+
() => this.mkEq(seq, left),
|
|
1984
|
+
() => this.mkLe(length, this.zero()),
|
|
1985
|
+
() => this.mkLe(seqLength, offset),
|
|
1986
|
+
]);
|
|
1987
|
+
}
|
|
1988
|
+
if (this.isOp(right, OP_STRING_ITOS)) return this.mkLt(this.getArg(right, 0), this.zero());
|
|
1989
|
+
if (this.isApp(right, OP_SEQ_POWER, 2))
|
|
1990
|
+
return this.mkOrOf([
|
|
1991
|
+
() => this.mkLe(this.getArg(right, 1), this.zero()),
|
|
1992
|
+
() => this.mkEq(this.getArg(right, 0), left),
|
|
1993
|
+
]);
|
|
1994
|
+
if (this.isApp(right, OP_SEQ_AT, 2)) {
|
|
1995
|
+
const offset = this.getArg(right, 1);
|
|
1996
|
+
const seqLength = this.mkLength(this.getArg(right, 0));
|
|
1997
|
+
return this.mkOrOf([
|
|
1998
|
+
() => this.mkLe(seqLength, offset),
|
|
1999
|
+
() => this.mkLt(offset, this.zero()),
|
|
2000
|
+
]);
|
|
2001
|
+
}
|
|
2002
|
+
return undefined;
|
|
2003
|
+
}
|
|
2004
|
+
|
|
2005
|
+
private mkOrOf(builders: (() => number)[]) {
|
|
2006
|
+
return this.manager.mkApp(
|
|
2007
|
+
OP_OR,
|
|
2008
|
+
builders.map((build) => build()),
|
|
2009
|
+
SORT_BOOL,
|
|
2010
|
+
);
|
|
2011
|
+
}
|
|
2012
|
+
|
|
2013
|
+
private getVectorHash(values: number[]) {
|
|
2014
|
+
const hashes = this.manager.hashes;
|
|
2015
|
+
return values.length === 0 ? 0 : getCompositeHash(values.map((value) => hashes[value]));
|
|
2016
|
+
}
|
|
2017
|
+
|
|
2018
|
+
reduceEq(left: number, right: number, eqs: EqPair[]): boolean | undefined {
|
|
2019
|
+
const manager = this.manager;
|
|
2020
|
+
const pair = { left: getConcat(manager, left, []), right: getConcat(manager, right, []) };
|
|
2021
|
+
const isChanged = this.reduceEqOf(pair, eqs);
|
|
2022
|
+
if (isChanged === undefined) return undefined;
|
|
2023
|
+
if (!isChanged) {
|
|
2024
|
+
eqs.push({ left, right });
|
|
2025
|
+
return false;
|
|
2026
|
+
}
|
|
2027
|
+
if (pair.left.length > 0 || pair.right.length > 0) {
|
|
2028
|
+
const sort = manager.sorts[pair.left.length === 0 ? pair.right[0] : pair.left[0]];
|
|
2029
|
+
const leftSeq = this.mkConcatOf(pair.left, sort);
|
|
2030
|
+
eqs.push({ left: leftSeq, right: this.mkConcatOf(pair.right, sort) });
|
|
2031
|
+
}
|
|
2032
|
+
return true;
|
|
2033
|
+
}
|
|
2034
|
+
|
|
2035
|
+
mkSeqReverse(seq: number) {
|
|
2036
|
+
const manager = this.manager;
|
|
2037
|
+
const elements: number[] = [];
|
|
2038
|
+
const todo = [seq];
|
|
2039
|
+
while (todo.length > 0) {
|
|
2040
|
+
const expr = todo.pop()!;
|
|
2041
|
+
if (this.isOp(expr, OP_SEQ_CONCAT)) {
|
|
2042
|
+
todo.push(...manager.getArgs(expr));
|
|
2043
|
+
continue;
|
|
2044
|
+
}
|
|
2045
|
+
if (isEmptySeq(manager, expr)) continue;
|
|
2046
|
+
elements.push(expr);
|
|
2047
|
+
}
|
|
2048
|
+
const reversed: number[] = [];
|
|
2049
|
+
for (const element of elements) {
|
|
2050
|
+
const chars = manager.getString(element);
|
|
2051
|
+
if (this.isOp(element, OP_SEQ_UNIT)) reversed.push(element);
|
|
2052
|
+
else if (chars !== undefined) reversed.push(manager.mkString([...chars].reverse()));
|
|
2053
|
+
else return undefined;
|
|
2054
|
+
}
|
|
2055
|
+
return mkConcatOf(manager, reversed, manager.sorts[seq]);
|
|
2056
|
+
}
|
|
2057
|
+
|
|
2058
|
+
mkLengthOf(seq: number) {
|
|
2059
|
+
const result = this.mkSeqLength(seq);
|
|
2060
|
+
return result === undefined
|
|
2061
|
+
? this.mkLength(seq)
|
|
2062
|
+
: typeof result === "number"
|
|
2063
|
+
? result
|
|
2064
|
+
: result.expr;
|
|
2065
|
+
}
|
|
2066
|
+
|
|
2067
|
+
addSeqs(left: readonly number[], right: readonly number[], eqs: EqPair[]) {
|
|
2068
|
+
if (left.length === 0 && right.length === 0) return;
|
|
2069
|
+
const sort = this.manager.sorts[left.length === 0 ? right[0] : left[0]];
|
|
2070
|
+
eqs.push({ left: this.mkConcatOf(left, sort), right: this.mkConcatOf(right, sort) });
|
|
2071
|
+
}
|
|
2072
|
+
|
|
2073
|
+
reduceEqOf(pair: SeqPair, eqs: EqPair[]): boolean | undefined {
|
|
2074
|
+
const leftHash = this.getVectorHash(pair.left);
|
|
2075
|
+
const rightHash = this.getVectorHash(pair.right);
|
|
2076
|
+
const size = eqs.length;
|
|
2077
|
+
pair.left = this.removeEmptyAndConcats(pair.left);
|
|
2078
|
+
pair.right = this.removeEmptyAndConcats(pair.right);
|
|
2079
|
+
const isSatisfiable =
|
|
2080
|
+
this.reduceBack(pair, eqs) &&
|
|
2081
|
+
this.reduceFront(pair, eqs) &&
|
|
2082
|
+
this.reduceItos(pair.left, pair.right, eqs, pair) &&
|
|
2083
|
+
this.reduceItos(pair.right, pair.left, eqs, pair) &&
|
|
2084
|
+
this.reduceValueClash(pair.left, pair.right) &&
|
|
2085
|
+
this.reduceByLength(pair, eqs) &&
|
|
2086
|
+
this.reduceSubsequence(pair, eqs) &&
|
|
2087
|
+
this.reduceNonOverlap(pair.left, pair.right) &&
|
|
2088
|
+
this.reduceNonOverlap(pair.right, pair.left) &&
|
|
2089
|
+
this.splitBag(pair, eqs);
|
|
2090
|
+
if (!isSatisfiable) return undefined;
|
|
2091
|
+
return (
|
|
2092
|
+
leftHash !== this.getVectorHash(pair.left) ||
|
|
2093
|
+
rightHash !== this.getVectorHash(pair.right) ||
|
|
2094
|
+
eqs.length !== size
|
|
2095
|
+
);
|
|
2096
|
+
}
|
|
2097
|
+
|
|
2098
|
+
private removeEmptyAndConcats(values: number[]) {
|
|
2099
|
+
const hasConcat = values.some((value) => this.isOp(value, OP_SEQ_CONCAT));
|
|
2100
|
+
const nonEmpty = values.filter((value) => !this.isEmpty(value));
|
|
2101
|
+
if (!hasConcat) return nonEmpty;
|
|
2102
|
+
const result: number[] = [];
|
|
2103
|
+
for (const value of nonEmpty) getConcat(this.manager, value, result);
|
|
2104
|
+
return result;
|
|
2105
|
+
}
|
|
2106
|
+
|
|
2107
|
+
private swap(pair: SeqPair) {
|
|
2108
|
+
const left = pair.left;
|
|
2109
|
+
pair.left = pair.right;
|
|
2110
|
+
pair.right = left;
|
|
2111
|
+
}
|
|
2112
|
+
|
|
2113
|
+
private reduceBack(pair: SeqPair, eqs: EqPair[]) {
|
|
2114
|
+
const manager = this.manager;
|
|
2115
|
+
while (pair.left.length > 0 && pair.right.length > 0) {
|
|
2116
|
+
if (this.isUnit(pair.right.at(-1)!) && manager.getString(pair.left.at(-1)!) !== undefined)
|
|
2117
|
+
this.swap(pair);
|
|
2118
|
+
const left = pair.left.at(-1)!;
|
|
2119
|
+
const right = pair.right.at(-1)!;
|
|
2120
|
+
const rightChars = manager.getString(right);
|
|
2121
|
+
const leftChars = manager.getString(left);
|
|
2122
|
+
if (left === right) {
|
|
2123
|
+
pair.left.pop();
|
|
2124
|
+
pair.right.pop();
|
|
2125
|
+
} else if (this.isUnit(left) && this.isUnit(right)) {
|
|
2126
|
+
if (this.areDistinct(this.getArg(left, 0), this.getArg(right, 0))) return false;
|
|
2127
|
+
eqs.push({ left: this.getArg(left, 0), right: this.getArg(right, 0) });
|
|
2128
|
+
pair.left.pop();
|
|
2129
|
+
pair.right.pop();
|
|
2130
|
+
} else if (this.isUnit(left) && rightChars !== undefined) {
|
|
2131
|
+
eqs.push({ left: manager.mkChar(rightChars.at(-1)!), right: this.getArg(left, 0) });
|
|
2132
|
+
pair.left.pop();
|
|
2133
|
+
if (rightChars.length === 1) pair.right.pop();
|
|
2134
|
+
else pair.right[pair.right.length - 1] = manager.mkString(rightChars.slice(0, -1));
|
|
2135
|
+
} else if (leftChars !== undefined && rightChars !== undefined) {
|
|
2136
|
+
const minLength = Math.min(leftChars.length, rightChars.length);
|
|
2137
|
+
for (let index = 0; index < minLength; index++)
|
|
2138
|
+
if (leftChars[leftChars.length - index - 1] !== rightChars[rightChars.length - index - 1])
|
|
2139
|
+
return false;
|
|
2140
|
+
pair.left.pop();
|
|
2141
|
+
pair.right.pop();
|
|
2142
|
+
if (minLength < leftChars.length)
|
|
2143
|
+
pair.left.push(manager.mkString(leftChars.slice(0, leftChars.length - minLength)));
|
|
2144
|
+
if (minLength < rightChars.length)
|
|
2145
|
+
pair.right.push(manager.mkString(rightChars.slice(0, rightChars.length - minLength)));
|
|
2146
|
+
} else break;
|
|
2147
|
+
}
|
|
2148
|
+
return true;
|
|
2149
|
+
}
|
|
2150
|
+
|
|
2151
|
+
private reduceFront(pair: SeqPair, eqs: EqPair[]) {
|
|
2152
|
+
const manager = this.manager;
|
|
2153
|
+
const heads = { left: 0, right: 0 };
|
|
2154
|
+
while (heads.left < pair.left.length && heads.right < pair.right.length) {
|
|
2155
|
+
if (
|
|
2156
|
+
this.isUnit(pair.right[heads.right]) &&
|
|
2157
|
+
manager.getString(pair.left[heads.left]) !== undefined
|
|
2158
|
+
) {
|
|
2159
|
+
this.swap(pair);
|
|
2160
|
+
const head = heads.left;
|
|
2161
|
+
heads.left = heads.right;
|
|
2162
|
+
heads.right = head;
|
|
2163
|
+
}
|
|
2164
|
+
const left = pair.left[heads.left];
|
|
2165
|
+
const right = pair.right[heads.right];
|
|
2166
|
+
const leftChars = manager.getString(left);
|
|
2167
|
+
const rightChars = manager.getString(right);
|
|
2168
|
+
if (left === right) {
|
|
2169
|
+
heads.left++;
|
|
2170
|
+
heads.right++;
|
|
2171
|
+
} else if (this.isUnit(left) && this.isUnit(right)) {
|
|
2172
|
+
if (this.areDistinct(this.getArg(left, 0), this.getArg(right, 0))) return false;
|
|
2173
|
+
eqs.push({ left: this.getArg(left, 0), right: this.getArg(right, 0) });
|
|
2174
|
+
heads.left++;
|
|
2175
|
+
heads.right++;
|
|
2176
|
+
} else if (this.isUnit(left) && rightChars !== undefined) {
|
|
2177
|
+
eqs.push({ left: manager.mkChar(rightChars[0]), right: this.getArg(left, 0) });
|
|
2178
|
+
heads.left++;
|
|
2179
|
+
if (rightChars.length === 1) heads.right++;
|
|
2180
|
+
else pair.right[heads.right] = manager.mkString(rightChars.slice(1));
|
|
2181
|
+
} else if (leftChars !== undefined && rightChars !== undefined) {
|
|
2182
|
+
const minLength = Math.min(leftChars.length, rightChars.length);
|
|
2183
|
+
for (let index = 0; index < minLength; index++)
|
|
2184
|
+
if (leftChars[index] !== rightChars[index]) return false;
|
|
2185
|
+
if (minLength === leftChars.length) heads.left++;
|
|
2186
|
+
else pair.left[heads.left] = manager.mkString(leftChars.slice(minLength));
|
|
2187
|
+
if (minLength === rightChars.length) heads.right++;
|
|
2188
|
+
else pair.right[heads.right] = manager.mkString(rightChars.slice(minLength));
|
|
2189
|
+
} else break;
|
|
2190
|
+
}
|
|
2191
|
+
pair.left.splice(0, heads.left);
|
|
2192
|
+
pair.right.splice(0, heads.right);
|
|
2193
|
+
return true;
|
|
2194
|
+
}
|
|
2195
|
+
|
|
2196
|
+
private getConstantString(values: number[]) {
|
|
2197
|
+
const manager = this.manager;
|
|
2198
|
+
const chars: number[] = [];
|
|
2199
|
+
for (const value of values) {
|
|
2200
|
+
const valueChars = manager.getString(value);
|
|
2201
|
+
const code = this.isUnit(value) ? manager.getChar(this.getArg(value, 0)) : -1;
|
|
2202
|
+
if (valueChars !== undefined) chars.push(...valueChars);
|
|
2203
|
+
else if (code !== -1) chars.push(code);
|
|
2204
|
+
else return undefined;
|
|
2205
|
+
}
|
|
2206
|
+
return chars;
|
|
2207
|
+
}
|
|
2208
|
+
|
|
2209
|
+
private reduceItos(first: number[], second: number[], eqs: EqPair[], pair: SeqPair) {
|
|
2210
|
+
if (first.length !== 1 || !this.isOp(first[0], OP_STRING_ITOS)) return true;
|
|
2211
|
+
const chars = this.getConstantString(second);
|
|
2212
|
+
if (chars === undefined) return true;
|
|
2213
|
+
if (!chars.every(isDigit)) return false;
|
|
2214
|
+
if (chars.length > 1 && chars[0] === 48) return false;
|
|
2215
|
+
if (chars.length === 0) return true;
|
|
2216
|
+
eqs.push({
|
|
2217
|
+
left: this.getArg(first[0], 0),
|
|
2218
|
+
right: this.mkInt(BigInt(String.fromCodePoint(...chars))),
|
|
2219
|
+
});
|
|
2220
|
+
pair.left = [];
|
|
2221
|
+
pair.right = [];
|
|
2222
|
+
return true;
|
|
2223
|
+
}
|
|
2224
|
+
|
|
2225
|
+
private reduceValueClash(left: number[], right: number[]) {
|
|
2226
|
+
if (left.length === 0 || right.length === 0) return true;
|
|
2227
|
+
const remaining = [...left];
|
|
2228
|
+
const isUnitValue = (expr: number) => this.isValue(expr) && this.isUnit(expr);
|
|
2229
|
+
for (const expr of right) {
|
|
2230
|
+
const index = remaining.indexOf(expr);
|
|
2231
|
+
if (index !== -1) {
|
|
2232
|
+
remaining[index] = remaining.at(-1)!;
|
|
2233
|
+
remaining.pop();
|
|
2234
|
+
continue;
|
|
2235
|
+
}
|
|
2236
|
+
if (!isUnitValue(expr)) return true;
|
|
2237
|
+
}
|
|
2238
|
+
return remaining.length === 0 || !remaining.every(isUnitValue);
|
|
2239
|
+
}
|
|
2240
|
+
|
|
2241
|
+
private hasVar(values: number[]) {
|
|
2242
|
+
return values.some((value) => this.getMinLength([value]).length === 0);
|
|
2243
|
+
}
|
|
2244
|
+
|
|
2245
|
+
private setEmpty(values: number[], isAll: boolean, eqs: EqPair[]) {
|
|
2246
|
+
let empty = -1;
|
|
2247
|
+
for (const value of values) {
|
|
2248
|
+
const minLength = this.getMinLength([value]);
|
|
2249
|
+
if (minLength.length > 0) {
|
|
2250
|
+
if (isAll) return false;
|
|
2251
|
+
continue;
|
|
2252
|
+
}
|
|
2253
|
+
if (minLength.isBounded) continue;
|
|
2254
|
+
if (empty === -1) empty = this.mkEmpty(this.manager.sorts[value]);
|
|
2255
|
+
eqs.push({ left: empty, right: value });
|
|
2256
|
+
}
|
|
2257
|
+
return true;
|
|
2258
|
+
}
|
|
2259
|
+
|
|
2260
|
+
private concatNonEmpty(values: number[]) {
|
|
2261
|
+
const sort = this.manager.sorts[values[0]];
|
|
2262
|
+
return this.mkConcatOf(
|
|
2263
|
+
values.filter(
|
|
2264
|
+
(value) =>
|
|
2265
|
+
this.isUnit(value) ||
|
|
2266
|
+
this.manager.getString(value) !== undefined ||
|
|
2267
|
+
this.isOp(value, OP_ITE),
|
|
2268
|
+
),
|
|
2269
|
+
sort,
|
|
2270
|
+
);
|
|
2271
|
+
}
|
|
2272
|
+
|
|
2273
|
+
private reduceByLength(pair: SeqPair, eqs: EqPair[]) {
|
|
2274
|
+
if (pair.left.length === 0 && pair.right.length === 0) return true;
|
|
2275
|
+
const leftLength = this.getMinLength(pair.left);
|
|
2276
|
+
const rightLength = this.getMinLength(pair.right);
|
|
2277
|
+
if (leftLength.isBounded && leftLength.length < rightLength.length) return false;
|
|
2278
|
+
if (rightLength.isBounded && rightLength.length < leftLength.length) return false;
|
|
2279
|
+
const isSameLength = leftLength.length === rightLength.length && leftLength.length > 0;
|
|
2280
|
+
const isLeftFixed = leftLength.isBounded && isSameLength && this.hasVar(pair.right);
|
|
2281
|
+
if (!isLeftFixed && !(rightLength.isBounded && isSameLength && this.hasVar(pair.left)))
|
|
2282
|
+
return true;
|
|
2283
|
+
if (!this.setEmpty(isLeftFixed ? pair.right : pair.left, false, eqs)) return false;
|
|
2284
|
+
const left = this.concatNonEmpty(pair.left);
|
|
2285
|
+
eqs.push({ left, right: this.concatNonEmpty(pair.right) });
|
|
2286
|
+
pair.left = [];
|
|
2287
|
+
pair.right = [];
|
|
2288
|
+
return true;
|
|
2289
|
+
}
|
|
2290
|
+
|
|
2291
|
+
private isNonOverlapping(first: number[], second: number[]): boolean {
|
|
2292
|
+
if (first.length > second.length) return this.isNonOverlapping(second, first);
|
|
2293
|
+
if (first.length === 0 || second.length === 0) return false;
|
|
2294
|
+
if (!first.every((expr) => this.isUnit(expr)) || !second.every((expr) => this.isUnit(expr)))
|
|
2295
|
+
return false;
|
|
2296
|
+
const canOverlap = (start: number, end: number, offset: number) => {
|
|
2297
|
+
for (let index = start; index < end; index++) {
|
|
2298
|
+
if (this.areDistinct(first[index], second[offset + index])) return false;
|
|
2299
|
+
if (first[index] !== second[offset + index]) return true;
|
|
2300
|
+
}
|
|
2301
|
+
return true;
|
|
2302
|
+
};
|
|
2303
|
+
for (let index = 1; index < first.length; index++)
|
|
2304
|
+
if (canOverlap(index, first.length, 0)) return false;
|
|
2305
|
+
for (let offset = 0; offset + first.length < second.length; offset++)
|
|
2306
|
+
if (canOverlap(0, first.length, offset)) return false;
|
|
2307
|
+
for (let offset = second.length - first.length; offset < second.length; offset++)
|
|
2308
|
+
if (canOverlap(0, second.length - offset, offset)) return false;
|
|
2309
|
+
return true;
|
|
2310
|
+
}
|
|
2311
|
+
|
|
2312
|
+
private reduceNonOverlap(left: number[], right: number[]) {
|
|
2313
|
+
if (!right.every((expr) => this.isUnit(expr))) return true;
|
|
2314
|
+
let pattern: number[] = [];
|
|
2315
|
+
for (const expr of left) {
|
|
2316
|
+
if (this.isUnit(expr)) pattern.push(expr);
|
|
2317
|
+
else if (pattern.length > 0) {
|
|
2318
|
+
if (this.isNonOverlapping(pattern, right)) return false;
|
|
2319
|
+
pattern = [];
|
|
2320
|
+
}
|
|
2321
|
+
}
|
|
2322
|
+
return pattern.length === 0 || !this.isNonOverlapping(pattern, right);
|
|
2323
|
+
}
|
|
2324
|
+
|
|
2325
|
+
private reduceSubsequence(pair: SeqPair, eqs: EqPair[]) {
|
|
2326
|
+
if (pair.left.length > pair.right.length) this.swap(pair);
|
|
2327
|
+
const left = pair.left;
|
|
2328
|
+
const right = pair.right;
|
|
2329
|
+
if (left.length === right.length) return true;
|
|
2330
|
+
if (left.length === 0 && right.length === 1) return true;
|
|
2331
|
+
const matched = new Set<number>();
|
|
2332
|
+
for (const expr of left) {
|
|
2333
|
+
const isUnit = this.isUnit(expr);
|
|
2334
|
+
const index = right.findIndex(
|
|
2335
|
+
(other, position) =>
|
|
2336
|
+
!matched.has(position) && (expr === other || (isUnit && this.isUnit(other))),
|
|
2337
|
+
);
|
|
2338
|
+
if (index === -1) return true;
|
|
2339
|
+
matched.add(index);
|
|
2340
|
+
}
|
|
2341
|
+
const kept: number[] = [];
|
|
2342
|
+
for (const [position, expr] of right.entries()) {
|
|
2343
|
+
if (matched.has(position)) kept.push(expr);
|
|
2344
|
+
else if (!this.setEmpty([expr], true, eqs)) return false;
|
|
2345
|
+
}
|
|
2346
|
+
if (kept.length === right.length) return true;
|
|
2347
|
+
pair.right = kept;
|
|
2348
|
+
if (left.length > 0) {
|
|
2349
|
+
const sort = this.manager.sorts[left[0]];
|
|
2350
|
+
const leftSeq = this.mkConcatOf(left, sort);
|
|
2351
|
+
eqs.push({ left: leftSeq, right: this.mkConcatOf(kept, sort) });
|
|
2352
|
+
pair.left = [];
|
|
2353
|
+
pair.right = [];
|
|
2354
|
+
}
|
|
2355
|
+
return true;
|
|
2356
|
+
}
|
|
2357
|
+
|
|
2358
|
+
private splitBag(pair: SeqPair, eqs: EqPair[]) {
|
|
2359
|
+
const leftBag = new Map<number, number>();
|
|
2360
|
+
const rightBag = new Map<number, number>();
|
|
2361
|
+
for (let index = pair.left.length, other = pair.right.length; ;) {
|
|
2362
|
+
if (!(index-- > 0)) break;
|
|
2363
|
+
if (!(other-- > 0)) break;
|
|
2364
|
+
if (!(index > 0 || other > 0)) break;
|
|
2365
|
+
leftBag.set(pair.left[index], getCount(leftBag, pair.left[index]) + 1);
|
|
2366
|
+
rightBag.set(pair.right[other], getCount(rightBag, pair.right[other]) + 1);
|
|
2367
|
+
if (!isSameBag(leftBag, rightBag)) continue;
|
|
2368
|
+
const left = this.mkConcatOf(pair.left.slice(index), this.manager.sorts[pair.left[index]]);
|
|
2369
|
+
const right = this.mkConcatOf(pair.right.slice(other), this.manager.sorts[pair.right[other]]);
|
|
2370
|
+
eqs.push({ left, right });
|
|
2371
|
+
leftBag.clear();
|
|
2372
|
+
rightBag.clear();
|
|
2373
|
+
pair.left.length = index;
|
|
2374
|
+
pair.right.length = other;
|
|
2375
|
+
}
|
|
2376
|
+
leftBag.clear();
|
|
2377
|
+
rightBag.clear();
|
|
2378
|
+
let start = 0;
|
|
2379
|
+
for (let index = 0; index + 1 < pair.left.length && index + 1 < pair.right.length; index++) {
|
|
2380
|
+
leftBag.set(pair.left[index], getCount(leftBag, pair.left[index]) + 1);
|
|
2381
|
+
rightBag.set(pair.right[index], getCount(rightBag, pair.right[index]) + 1);
|
|
2382
|
+
if (!isSameBag(leftBag, rightBag)) continue;
|
|
2383
|
+
const left = this.mkConcatOf(
|
|
2384
|
+
pair.left.slice(start, index + 1),
|
|
2385
|
+
this.manager.sorts[pair.left[index]],
|
|
2386
|
+
);
|
|
2387
|
+
const right = this.mkConcatOf(
|
|
2388
|
+
pair.right.slice(start, index + 1),
|
|
2389
|
+
this.manager.sorts[pair.right[index]],
|
|
2390
|
+
);
|
|
2391
|
+
eqs.push({ left, right });
|
|
2392
|
+
leftBag.clear();
|
|
2393
|
+
rightBag.clear();
|
|
2394
|
+
start = index + 1;
|
|
2395
|
+
}
|
|
2396
|
+
if (start > 0) {
|
|
2397
|
+
pair.left.splice(0, start);
|
|
2398
|
+
pair.right.splice(0, start);
|
|
2399
|
+
}
|
|
2400
|
+
return true;
|
|
2401
|
+
}
|
|
2402
|
+
}
|