tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479
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 +2 -1
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +41 -37
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +21 -4
- package/dist/index.d.ts +21 -4
- 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 +2681 -425
- package/dist/prove.js +2681 -425
- package/dist/run.cjs +41 -42
- package/dist/run.js +41 -42
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -89
- package/dist/transfer.js +97 -89
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +72 -39
- package/src/bags.ts +50 -29
- package/src/builtins.ts +8 -16
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +321 -0
- package/src/check.ts +828 -770
- package/src/cli/options.ts +6 -31
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +224 -212
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +1 -2
- package/src/cli/tlc.ts +65 -712
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +28 -20
- package/src/coverage.ts +255 -20
- package/src/dependencies.ts +96 -27
- package/src/dfid.ts +115 -50
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +175 -373
- package/src/errors.ts +40 -5
- package/src/evaluate.ts +429 -139
- package/src/exit-codes.ts +28 -12
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +178 -17
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/json.ts +4 -7
- package/src/levels.ts +708 -272
- package/src/lexer.ts +17 -5
- package/src/liveness-checker.ts +707 -249
- package/src/liveness.ts +148 -95
- package/src/obligations/action.ts +14 -17
- package/src/obligations/anonymize.ts +37 -16
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +36 -8
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +66 -54
- package/src/obligations/index.ts +39 -9
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +28 -41
- package/src/obligations/normalize.ts +27 -18
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +48 -18
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +55 -50
- package/src/obligations/source.ts +120 -74
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +5 -7
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +17 -31
- package/src/parallel.ts +29 -47
- package/src/parser.ts +757 -326
- package/src/pretty-print.ts +1 -1
- package/src/prover/decide-pool.ts +3 -3
- package/src/prover/deciders.ts +12 -9
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +72 -42
- 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 +158 -7
- package/src/prover/isabelle/isar/method.ts +509 -212
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +487 -76
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +89 -14
- package/src/prover/isabelle/provers/blast/blast.ts +7 -65
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +19 -30
- package/src/prover/isabelle/pure/bicompose.ts +9 -27
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +2 -10
- package/src/prover/isabelle/pure/drule.ts +72 -6
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +1 -3
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
- package/src/prover/isabelle/pure/rewriter.ts +9 -20
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +2 -3
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +42 -37
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +3 -5
- package/src/prover/isabelle/pure/thm.ts +14 -13
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +18 -16
- package/src/prover/isabelle/tla/context.ts +58 -11
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +49 -21
- package/src/prover/isabelle/tla/simpdata.ts +1 -12
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +30 -31
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/fingerprint.ts +2 -5
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/prep/methods.ts +181 -51
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +395 -94
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +43 -8
- package/src/prover/smt/data.ts +498 -379
- package/src/prover/smt/encode.ts +148 -57
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1016 -618
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -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 -1
- 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 +624 -9
- 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 +319 -0
- package/src/prover/smt/solver/asserted-formulas.ts +240 -56
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1483 -45
- package/src/prover/smt/solver/auf-solver.ts +25 -18
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -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 +127 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +598 -128
- package/src/prover/smt/solver/ctx-simplify.ts +29 -14
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -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 +93 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +207 -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 +298 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +7 -8
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +227 -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 +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -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 +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +886 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +178 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +34 -16
- 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 +111 -39
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- 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 -1
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +30 -11
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +68 -17
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +122 -90
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- 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 +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +106 -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 -28
- package/src/prover/smt/solver/model-evaluator.ts +190 -12
- package/src/prover/smt/solver/model-finder.ts +12 -18
- package/src/prover/smt/solver/model-generator.ts +104 -35
- package/src/prover/smt/solver/model-macro-solver.ts +49 -46
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -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 +495 -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 +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -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 +219 -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 +485 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
- package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +427 -229
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
- package/src/prover/smt/solver/nlsat/solver.ts +293 -92
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +110 -24
- 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 +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -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 +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
- package/src/prover/smt/solver/poly-rewriter.ts +259 -57
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +648 -19
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +634 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +39 -19
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +829 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
- package/src/prover/smt/solver/quantifier-manager.ts +22 -25
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -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 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
- package/src/prover/smt/solver/rewriter.ts +505 -60
- package/src/prover/smt/solver/rlimit.ts +45 -5
- 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 +589 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +190 -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 +2107 -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 +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -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 +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -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 +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -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 +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
- package/src/prover/smt/solver/smtlib-script.ts +2136 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +128 -23
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +2176 -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 +1210 -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 +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
- package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
- package/src/prover/smt/solver/theory-lra-state.ts +7 -23
- package/src/prover/smt/solver/theory-lra.ts +189 -2
- package/src/prover/smt/solver/theory-pb.ts +951 -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 +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +57 -26
- package/src/prover/tlapm/tlapm.ts +15 -9
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -0
- package/src/prover/zenon/check/check.ts +1 -2
- package/src/prover/zenon/check/records.ts +1 -1
- package/src/prover/zenon/check/relations.ts +2 -1
- package/src/prover/zenon/check/rewrites.ts +2 -15
- package/src/prover/zenon/check/sets.ts +40 -58
- package/src/prover/zenon/check/terms.ts +1 -2
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +2 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +28 -2
- package/src/prover/zenon/index-table.ts +16 -23
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +37 -39
- package/src/prover/zenon/llproof.ts +2 -13
- package/src/prover/zenon/mltoll.ts +12 -30
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +9 -8
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +11 -19
- package/src/prover/zenon/tla/functions.ts +2 -4
- package/src/prover/zenon/tla/llproof.ts +9 -13
- package/src/prover/zenon/tla/records.ts +1 -8
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +22 -22
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +7 -8
- package/src/resolve.ts +1327 -328
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +384 -0
- package/src/sany/generator-def-entries.ts +297 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1123 -0
- package/src/sany/generator-proofs.ts +668 -0
- package/src/sany/generator.ts +161 -2625
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +32 -23
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +3 -4
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +46 -44
- package/src/sany/xml.ts +25 -58
- package/src/search.ts +513 -165
- package/src/simulate.ts +340 -251
- package/src/spec-description.ts +48 -55
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +72 -54
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +564 -138
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +56 -28
- package/src/symmetry.ts +4 -3
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +23 -18
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +6 -5
- package/src/tlc/replay.ts +152 -58
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +12 -11
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +27 -60
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +2 -4
- package/src/typescript/collections.ts +34 -20
- package/src/typescript/compile.ts +1 -3
- package/src/typescript/formula.ts +5 -3
- package/src/typescript/model.ts +4 -5
- package/src/typescript/steps.ts +20 -18
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +208 -227
- package/src/prover/isabelle/isar/statement.ts +0 -52
- 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,1901 @@
|
|
|
1
|
+
import { isAstLess } from "./ast-lt";
|
|
2
|
+
import {
|
|
3
|
+
type AstManager,
|
|
4
|
+
FAMILY_BV,
|
|
5
|
+
KIND_APP,
|
|
6
|
+
KIND_VAR,
|
|
7
|
+
OP_ADD,
|
|
8
|
+
OP_AND,
|
|
9
|
+
OP_BADD,
|
|
10
|
+
OP_BAND,
|
|
11
|
+
OP_BASHR,
|
|
12
|
+
OP_BCOMP,
|
|
13
|
+
OP_BIT2BOOL,
|
|
14
|
+
OP_BLSHR,
|
|
15
|
+
OP_BMUL,
|
|
16
|
+
OP_BNAND,
|
|
17
|
+
OP_BNEG,
|
|
18
|
+
OP_BNEG_OVFL,
|
|
19
|
+
OP_BNOR,
|
|
20
|
+
OP_BNOT,
|
|
21
|
+
OP_BOR,
|
|
22
|
+
OP_BREDAND,
|
|
23
|
+
OP_BREDOR,
|
|
24
|
+
OP_BSADD_OVFL,
|
|
25
|
+
OP_BSDIV,
|
|
26
|
+
OP_BSDIV0,
|
|
27
|
+
OP_BSDIV_I,
|
|
28
|
+
OP_BSDIV_OVFL,
|
|
29
|
+
OP_BSHL,
|
|
30
|
+
OP_BSMOD,
|
|
31
|
+
OP_BSMOD0,
|
|
32
|
+
OP_BSMOD_I,
|
|
33
|
+
OP_BSMUL_NO_OVFL,
|
|
34
|
+
OP_BSMUL_NO_UDFL,
|
|
35
|
+
OP_BSMUL_OVFL,
|
|
36
|
+
OP_BSREM,
|
|
37
|
+
OP_BSREM0,
|
|
38
|
+
OP_BSREM_I,
|
|
39
|
+
OP_BSSUB_OVFL,
|
|
40
|
+
OP_BSUB,
|
|
41
|
+
OP_BUADD_OVFL,
|
|
42
|
+
OP_BUDIV,
|
|
43
|
+
OP_BUDIV0,
|
|
44
|
+
OP_BUDIV_I,
|
|
45
|
+
OP_BUMUL_NO_OVFL,
|
|
46
|
+
OP_BUMUL_OVFL,
|
|
47
|
+
OP_BUREM,
|
|
48
|
+
OP_BUREM0,
|
|
49
|
+
OP_BUREM_I,
|
|
50
|
+
OP_BUSUB_OVFL,
|
|
51
|
+
OP_BXNOR,
|
|
52
|
+
OP_BXOR,
|
|
53
|
+
OP_CONCAT,
|
|
54
|
+
OP_EQ,
|
|
55
|
+
OP_EXT_ROTATE_LEFT,
|
|
56
|
+
OP_EXT_ROTATE_RIGHT,
|
|
57
|
+
OP_EXTRACT,
|
|
58
|
+
OP_IMPLIES,
|
|
59
|
+
OP_INT2BV,
|
|
60
|
+
OP_ITE,
|
|
61
|
+
OP_MKBV,
|
|
62
|
+
OP_MUL,
|
|
63
|
+
OP_OR,
|
|
64
|
+
OP_REPEAT,
|
|
65
|
+
OP_ROTATE_LEFT,
|
|
66
|
+
OP_ROTATE_RIGHT,
|
|
67
|
+
OP_SBV2INT,
|
|
68
|
+
OP_SGEQ,
|
|
69
|
+
OP_SGT,
|
|
70
|
+
OP_SIGN_EXT,
|
|
71
|
+
OP_SLEQ,
|
|
72
|
+
OP_SLT,
|
|
73
|
+
OP_SUB,
|
|
74
|
+
OP_UBV2INT,
|
|
75
|
+
OP_UGEQ,
|
|
76
|
+
OP_UGT,
|
|
77
|
+
OP_ULEQ,
|
|
78
|
+
OP_ULT,
|
|
79
|
+
OP_XOR,
|
|
80
|
+
OP_ZERO_EXT,
|
|
81
|
+
SORT_BOOL,
|
|
82
|
+
SORT_INT,
|
|
83
|
+
} from "./ast";
|
|
84
|
+
import { mkBvApp } from "./bv-decl-plugin";
|
|
85
|
+
import { type ArithRewriterOptions, PolyRewriter } from "./poly-rewriter";
|
|
86
|
+
import { getMultInverse, Rational } from "./rational";
|
|
87
|
+
import type { Rewrite } from "./rewriter-tpl";
|
|
88
|
+
|
|
89
|
+
type Result = number | Rewrite | undefined;
|
|
90
|
+
|
|
91
|
+
export interface BvRewriterOptions {
|
|
92
|
+
readonly isHiDiv0: boolean;
|
|
93
|
+
readonly isMul2concat: boolean;
|
|
94
|
+
readonly isSplitConcatEq: boolean;
|
|
95
|
+
readonly isMkbv2num?: boolean;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
export const DEFAULT_BV_OPTIONS: Omit<BvRewriterOptions, "isHiDiv0"> = {
|
|
99
|
+
isMul2concat: false,
|
|
100
|
+
isSplitConcatEq: false,
|
|
101
|
+
};
|
|
102
|
+
|
|
103
|
+
interface BoolRewrites {
|
|
104
|
+
mkEq: (left: number, right: number) => number;
|
|
105
|
+
mkIte: (condition: number, thenExpr: number, elseExpr: number) => number;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
const rewrite = (expr: number, depth: number): Rewrite => ({ expr, depth });
|
|
109
|
+
|
|
110
|
+
const getPowerOfTwo = (bits: number) => 1n << BigInt(bits);
|
|
111
|
+
|
|
112
|
+
const getMod = (value: bigint, modulus: bigint) => ((value % modulus) + modulus) % modulus;
|
|
113
|
+
|
|
114
|
+
const getPowerOfTwoExponent = (value: bigint) => {
|
|
115
|
+
if (value <= 0n || (value & (value - 1n)) !== 0n) return -1;
|
|
116
|
+
return value.toString(2).length - 1;
|
|
117
|
+
};
|
|
118
|
+
|
|
119
|
+
const getAbs = (value: bigint) => (value < 0n ? -value : value);
|
|
120
|
+
|
|
121
|
+
export class BvRewriter extends PolyRewriter {
|
|
122
|
+
constructor(
|
|
123
|
+
manager: AstManager,
|
|
124
|
+
options: ArithRewriterOptions,
|
|
125
|
+
private bvOptions: BvRewriterOptions,
|
|
126
|
+
private boolRewrites: BoolRewrites,
|
|
127
|
+
) {
|
|
128
|
+
super(manager, { ...options, isSortSums: true });
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
protected isNumeral(expr: number) {
|
|
132
|
+
return this.manager.isBvNumeral(expr);
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
protected normalize(value: Rational) {
|
|
136
|
+
return Rational.of(getMod(value.num, getPowerOfTwo(this.manager.getBvSize(this.currSort))));
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
protected mkNumeral(value: Rational) {
|
|
140
|
+
return this.manager.mkBvNumeral(value.num, this.manager.getBvSize(this.currSort));
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
protected isAdd(expr: number) {
|
|
144
|
+
return this.manager.getOp(expr) === OP_BADD;
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
protected isMul(expr: number) {
|
|
148
|
+
return this.manager.getOp(expr) === OP_BMUL;
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
protected isArithTerm(expr: number) {
|
|
152
|
+
return this.manager.kinds[expr] === KIND_APP && this.manager.getFamily(expr) === FAMILY_BV;
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
protected mkAddTerm(args: number[]) {
|
|
156
|
+
return mkBvApp(this.manager, OP_BADD, args);
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
protected mkMulTerm(args: number[]) {
|
|
160
|
+
return mkBvApp(this.manager, OP_BMUL, args);
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
private getSize(expr: number) {
|
|
164
|
+
return this.manager.getBvSize(this.manager.sorts[expr]);
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
private getNumeral(expr: number) {
|
|
168
|
+
return this.manager.isBvNumeral(expr) ? this.manager.getBvNumeralValue(expr) : undefined;
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
private mkBv(value: bigint, width: number) {
|
|
172
|
+
return this.manager.mkBvNumeral(value, width);
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
private mkZero(width: number) {
|
|
176
|
+
return this.manager.mkBvNumeral(0n, width);
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
private mkOne(width: number) {
|
|
180
|
+
return this.manager.mkBvNumeral(1n, width);
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
private mkAllOnes(width: number) {
|
|
184
|
+
return this.manager.mkBvNumeral(getPowerOfTwo(width) - 1n, width);
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
private app(op: number, args: number[], parameters: number[] = []) {
|
|
188
|
+
return mkBvApp(this.manager, op, args, parameters);
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
private norm(value: bigint, width: number, isSigned = false) {
|
|
192
|
+
const normalized = getMod(value, getPowerOfTwo(width));
|
|
193
|
+
return isSigned && normalized >= getPowerOfTwo(width - 1)
|
|
194
|
+
? normalized - getPowerOfTwo(width)
|
|
195
|
+
: normalized;
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
private hasSignBit(value: bigint, width: number) {
|
|
199
|
+
return this.norm(value, width) >= getPowerOfTwo(width - 1);
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
private isAllOnes(expr: number) {
|
|
203
|
+
return this.getNumeral(expr) === getPowerOfTwo(this.getSize(expr)) - 1n;
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
private isBinary(expr: number, op: number) {
|
|
207
|
+
return this.manager.getOp(expr) === op && this.manager.getNumArgs(expr) === 2;
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
private isConcat(expr: number) {
|
|
211
|
+
return this.manager.getOp(expr) === OP_CONCAT;
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
private isExtract(expr: number) {
|
|
215
|
+
return this.manager.getOp(expr) === OP_EXTRACT;
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
private getParameter(expr: number, index: number) {
|
|
219
|
+
return this.manager.funcDecls[this.manager.decls[expr]].parameters[index];
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
private isIte(expr: number) {
|
|
223
|
+
return this.manager.getOp(expr) === OP_ITE;
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
private mkIteTerm(condition: number, thenExpr: number, elseExpr: number) {
|
|
227
|
+
return this.manager.mkApp(
|
|
228
|
+
OP_ITE,
|
|
229
|
+
[condition, thenExpr, elseExpr],
|
|
230
|
+
this.manager.sorts[thenExpr],
|
|
231
|
+
);
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
private mkAndTerm(args: number[]) {
|
|
235
|
+
return this.manager.mkApp(OP_AND, args, SORT_BOOL);
|
|
236
|
+
}
|
|
237
|
+
|
|
238
|
+
private mkOrTerm(args: number[]) {
|
|
239
|
+
return this.manager.mkApp(OP_OR, args, SORT_BOOL);
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
mkExtractTerm(high: number, low: number, arg: number) {
|
|
243
|
+
let target = arg;
|
|
244
|
+
let newHigh = high;
|
|
245
|
+
let newLow = low;
|
|
246
|
+
while (this.isExtract(target)) {
|
|
247
|
+
newLow += this.getParameter(target, 1);
|
|
248
|
+
newHigh += this.getParameter(target, 1);
|
|
249
|
+
target = this.manager.getArg(target, 0);
|
|
250
|
+
}
|
|
251
|
+
if (
|
|
252
|
+
newLow === 0 &&
|
|
253
|
+
newHigh + 1 === this.getSize(target) &&
|
|
254
|
+
this.manager.kinds[target] === KIND_APP
|
|
255
|
+
)
|
|
256
|
+
return target;
|
|
257
|
+
return this.app(OP_EXTRACT, [target], [newHigh, newLow]);
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
private mkConcatTerm(args: number[]) {
|
|
261
|
+
return this.app(OP_CONCAT, args);
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
private mkNotTerm(arg: number) {
|
|
265
|
+
return this.app(OP_BNOT, [arg]);
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
mkAppCore(decl: number, args: number[]): Result {
|
|
269
|
+
const manager = this.manager;
|
|
270
|
+
const funcDecl = manager.funcDecls[decl];
|
|
271
|
+
const parameters = funcDecl.parameters;
|
|
272
|
+
const op = funcDecl.op;
|
|
273
|
+
switch (op) {
|
|
274
|
+
case OP_ULEQ:
|
|
275
|
+
return this.mkLeqCore(false, args[0], args[1]);
|
|
276
|
+
case OP_UGEQ:
|
|
277
|
+
return this.mkLeqCore(false, args[1], args[0]) ?? this.app(OP_ULEQ, [args[1], args[0]]);
|
|
278
|
+
case OP_ULT:
|
|
279
|
+
return this.mkUlt(args[0], args[1]);
|
|
280
|
+
case OP_UGT:
|
|
281
|
+
return this.mkUlt(args[1], args[0]);
|
|
282
|
+
case OP_SLEQ:
|
|
283
|
+
return this.mkLeqCore(true, args[0], args[1]);
|
|
284
|
+
case OP_SGEQ:
|
|
285
|
+
return this.mkLeqCore(true, args[1], args[0]) ?? this.app(OP_SLEQ, [args[1], args[0]]);
|
|
286
|
+
case OP_SLT:
|
|
287
|
+
return this.mkSlt(args[0], args[1]);
|
|
288
|
+
case OP_SGT:
|
|
289
|
+
return this.mkSlt(args[1], args[0]);
|
|
290
|
+
case OP_BADD:
|
|
291
|
+
return this.mkBvAdd(args);
|
|
292
|
+
case OP_BMUL:
|
|
293
|
+
return this.mkBvMul(args);
|
|
294
|
+
case OP_BSUB:
|
|
295
|
+
return this.mkSub(args);
|
|
296
|
+
case OP_BNEG:
|
|
297
|
+
return this.mkUminus(args[0]);
|
|
298
|
+
case OP_BNEG_OVFL:
|
|
299
|
+
return rewrite(
|
|
300
|
+
manager.mkEq(
|
|
301
|
+
args[0],
|
|
302
|
+
this.mkBv(getPowerOfTwo(this.getSize(args[0]) - 1), this.getSize(args[0])),
|
|
303
|
+
),
|
|
304
|
+
3,
|
|
305
|
+
);
|
|
306
|
+
case OP_BSHL:
|
|
307
|
+
return this.mkBvShl(args[0], args[1]);
|
|
308
|
+
case OP_BLSHR:
|
|
309
|
+
return this.mkBvLshr(args[0], args[1]);
|
|
310
|
+
case OP_BASHR:
|
|
311
|
+
return this.mkBvAshr(args[0], args[1]);
|
|
312
|
+
case OP_BSDIV:
|
|
313
|
+
case OP_BSDIV_I:
|
|
314
|
+
return this.mkBvSdiv(args[0], args[1], op === OP_BSDIV_I || this.bvOptions.isHiDiv0);
|
|
315
|
+
case OP_BUDIV:
|
|
316
|
+
case OP_BUDIV_I:
|
|
317
|
+
return this.mkBvUdiv(args[0], args[1], op === OP_BUDIV_I || this.bvOptions.isHiDiv0);
|
|
318
|
+
case OP_BSREM:
|
|
319
|
+
case OP_BSREM_I:
|
|
320
|
+
return this.mkBvSrem(args[0], args[1], op === OP_BSREM_I || this.bvOptions.isHiDiv0);
|
|
321
|
+
case OP_BUREM:
|
|
322
|
+
case OP_BUREM_I:
|
|
323
|
+
return this.mkBvUrem(args[0], args[1], op === OP_BUREM_I || this.bvOptions.isHiDiv0);
|
|
324
|
+
case OP_BSMOD:
|
|
325
|
+
case OP_BSMOD_I:
|
|
326
|
+
return this.mkBvSmod(args[0], args[1], op === OP_BSMOD_I || this.bvOptions.isHiDiv0);
|
|
327
|
+
case OP_CONCAT:
|
|
328
|
+
return this.mkConcat(args);
|
|
329
|
+
case OP_EXTRACT:
|
|
330
|
+
return this.mkExtract(parameters[0], parameters[1], args[0]);
|
|
331
|
+
case OP_REPEAT:
|
|
332
|
+
return parameters[0] === 1
|
|
333
|
+
? args[0]
|
|
334
|
+
: rewrite(this.mkConcatTerm(Array.from({ length: parameters[0] }, () => args[0])), 1);
|
|
335
|
+
case OP_ZERO_EXT:
|
|
336
|
+
return this.mkZeroExtend(parameters[0], args[0]);
|
|
337
|
+
case OP_SIGN_EXT:
|
|
338
|
+
return this.mkSignExtend(parameters[0], args[0]);
|
|
339
|
+
case OP_BOR:
|
|
340
|
+
return this.mkBvOr(args);
|
|
341
|
+
case OP_BXOR:
|
|
342
|
+
return this.mkBvXor(args);
|
|
343
|
+
case OP_BNOT:
|
|
344
|
+
return this.mkBvNot(args[0]);
|
|
345
|
+
case OP_BAND:
|
|
346
|
+
return this.mkBvAnd(args);
|
|
347
|
+
case OP_BNAND:
|
|
348
|
+
return rewrite(
|
|
349
|
+
this.app(
|
|
350
|
+
OP_BOR,
|
|
351
|
+
args.map((arg) => this.mkNotTerm(arg)),
|
|
352
|
+
),
|
|
353
|
+
2,
|
|
354
|
+
);
|
|
355
|
+
case OP_BNOR:
|
|
356
|
+
return rewrite(this.mkNotTerm(this.app(OP_BOR, args)), 2);
|
|
357
|
+
case OP_BXNOR:
|
|
358
|
+
return this.mkBvXnor(args);
|
|
359
|
+
case OP_ROTATE_LEFT:
|
|
360
|
+
return this.mkRotateLeft(parameters[0], args[0]);
|
|
361
|
+
case OP_ROTATE_RIGHT:
|
|
362
|
+
return this.mkRotateRight(parameters[0], args[0]);
|
|
363
|
+
case OP_EXT_ROTATE_LEFT:
|
|
364
|
+
return this.mkExtRotate(true, args[0], args[1]);
|
|
365
|
+
case OP_EXT_ROTATE_RIGHT:
|
|
366
|
+
return this.mkExtRotate(false, args[0], args[1]);
|
|
367
|
+
case OP_UBV2INT:
|
|
368
|
+
return this.mkUbv2int(args[0]);
|
|
369
|
+
case OP_SBV2INT:
|
|
370
|
+
return rewrite(this.mkSbv2intAsUbv2int(args[0]), 2);
|
|
371
|
+
case OP_INT2BV:
|
|
372
|
+
return this.mkInt2bv(parameters[0], args[0]);
|
|
373
|
+
case OP_BREDOR:
|
|
374
|
+
return this.isNumeral(args[0])
|
|
375
|
+
? this.getNumeral(args[0]) === 0n
|
|
376
|
+
? this.mkZero(1)
|
|
377
|
+
: this.mkOne(1)
|
|
378
|
+
: undefined;
|
|
379
|
+
case OP_BREDAND:
|
|
380
|
+
return this.isNumeral(args[0])
|
|
381
|
+
? this.isAllOnes(args[0])
|
|
382
|
+
? this.mkOne(1)
|
|
383
|
+
: this.mkZero(1)
|
|
384
|
+
: undefined;
|
|
385
|
+
case OP_BCOMP:
|
|
386
|
+
if (args[0] === args[1]) return this.mkOne(1);
|
|
387
|
+
if (this.isNumeral(args[0]) && this.isNumeral(args[1])) return this.mkZero(1);
|
|
388
|
+
return rewrite(
|
|
389
|
+
this.mkIteTerm(manager.mkEq(args[0], args[1]), this.mkOne(1), this.mkZero(1)),
|
|
390
|
+
2,
|
|
391
|
+
);
|
|
392
|
+
case OP_MKBV:
|
|
393
|
+
return this.mkMkbv(args);
|
|
394
|
+
case OP_BIT2BOOL:
|
|
395
|
+
return this.mkBit2boolIndex(args[0], parameters[0]);
|
|
396
|
+
case OP_BSMUL_NO_OVFL:
|
|
397
|
+
return this.mkBvsmulNoOverflow(args, true);
|
|
398
|
+
case OP_BSMUL_NO_UDFL:
|
|
399
|
+
return this.mkBvsmulNoOverflow(args, false);
|
|
400
|
+
case OP_BUMUL_NO_OVFL:
|
|
401
|
+
return this.mkBvumulNoOverflow(args);
|
|
402
|
+
case OP_BSMUL_OVFL: {
|
|
403
|
+
const noOverflow = manager.mkNot(this.app(OP_BSMUL_NO_OVFL, [args[0], args[1]]));
|
|
404
|
+
const noUnderflow = manager.mkNot(this.app(OP_BSMUL_NO_UDFL, [args[0], args[1]]));
|
|
405
|
+
return rewrite(this.mkOrTerm([noOverflow, noUnderflow]), 4);
|
|
406
|
+
}
|
|
407
|
+
case OP_BUMUL_OVFL:
|
|
408
|
+
return rewrite(manager.mkNot(this.app(OP_BUMUL_NO_OVFL, [args[0], args[1]])), 2);
|
|
409
|
+
case OP_BSDIV_OVFL: {
|
|
410
|
+
const size = this.getSize(args[1]);
|
|
411
|
+
const minSigned = this.mkBv(getPowerOfTwo(size - 1), size);
|
|
412
|
+
const minusOne = this.mkAllOnes(size);
|
|
413
|
+
const first = manager.mkEq(args[0], minSigned);
|
|
414
|
+
return rewrite(this.mkAndTerm([first, manager.mkEq(args[1], minusOne)]), 4);
|
|
415
|
+
}
|
|
416
|
+
case OP_BUADD_OVFL: {
|
|
417
|
+
const size = this.getSize(args[0]);
|
|
418
|
+
const first = this.getExpr(this.mkZeroExtend(1, args[0]));
|
|
419
|
+
const second = this.getExpr(this.mkZeroExtend(1, args[1]));
|
|
420
|
+
const sum = this.mkBvAddExpr(first, second);
|
|
421
|
+
const carry = this.mkExtractTerm(size, size, sum);
|
|
422
|
+
return rewrite(manager.mkEq(carry, this.mkOne(1)), 4);
|
|
423
|
+
}
|
|
424
|
+
case OP_BSADD_OVFL:
|
|
425
|
+
return rewrite(this.mkBvsaddOverUnderflow(args[0], args[1]), 4);
|
|
426
|
+
case OP_BUSUB_OVFL:
|
|
427
|
+
return this.mkUlt(args[0], args[1]);
|
|
428
|
+
case OP_BSSUB_OVFL: {
|
|
429
|
+
const size = this.getSize(args[0]);
|
|
430
|
+
const minSigned = this.mkBv(getPowerOfTwo(size - 1), size);
|
|
431
|
+
const overflow = this.mkBvsaddOverUnderflow(args[0], this.app(OP_BNEG, [args[1]]));
|
|
432
|
+
const isNonNegative = this.app(OP_SLEQ, [this.mkZero(size), args[0]]);
|
|
433
|
+
return rewrite(
|
|
434
|
+
this.mkIteTerm(manager.mkEq(args[1], minSigned), isNonNegative, overflow),
|
|
435
|
+
4,
|
|
436
|
+
);
|
|
437
|
+
}
|
|
438
|
+
default:
|
|
439
|
+
return undefined;
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
|
|
443
|
+
private getExpr(result: number | Rewrite) {
|
|
444
|
+
return typeof result === "number" ? result : result.expr;
|
|
445
|
+
}
|
|
446
|
+
|
|
447
|
+
private mkBvAddExpr(first: number, second: number) {
|
|
448
|
+
const result = this.mkBvAdd([first, second]);
|
|
449
|
+
return result === undefined ? this.app(OP_BADD, [first, second]) : this.getExpr(result);
|
|
450
|
+
}
|
|
451
|
+
|
|
452
|
+
private mkUlt(first: number, second: number) {
|
|
453
|
+
return rewrite(this.manager.mkNot(this.app(OP_ULEQ, [second, first])), 2);
|
|
454
|
+
}
|
|
455
|
+
|
|
456
|
+
private mkSlt(first: number, second: number) {
|
|
457
|
+
return rewrite(this.manager.mkNot(this.app(OP_SLEQ, [second, first])), 2);
|
|
458
|
+
}
|
|
459
|
+
|
|
460
|
+
private mkBvsaddOverUnderflow(first: number, second: number) {
|
|
461
|
+
const zero = this.mkZero(this.getSize(first));
|
|
462
|
+
const sum = this.mkBvAddExpr(first, second);
|
|
463
|
+
const isFirstPositive = this.app(OP_SLT, [zero, first]);
|
|
464
|
+
const isSecondPositive = this.app(OP_SLT, [zero, second]);
|
|
465
|
+
const arePositive = this.mkAndTerm([isFirstPositive, isSecondPositive]);
|
|
466
|
+
const overflow = this.mkAndTerm([arePositive, this.app(OP_SLEQ, [sum, zero])]);
|
|
467
|
+
const isFirstNegative = this.app(OP_SLT, [first, zero]);
|
|
468
|
+
const isSecondNegative = this.app(OP_SLT, [second, zero]);
|
|
469
|
+
const areNegative = this.mkAndTerm([isFirstNegative, isSecondNegative]);
|
|
470
|
+
const isSumNonNegative = this.mkLeqCore(true, zero, sum);
|
|
471
|
+
const underflow = this.mkAndTerm([
|
|
472
|
+
areNegative,
|
|
473
|
+
isSumNonNegative === undefined
|
|
474
|
+
? this.app(OP_SLEQ, [zero, sum])
|
|
475
|
+
: this.getExpr(isSumNonNegative),
|
|
476
|
+
]);
|
|
477
|
+
return this.mkOrTerm([overflow, underflow]);
|
|
478
|
+
}
|
|
479
|
+
|
|
480
|
+
private isZeroExtended(expr: number) {
|
|
481
|
+
if (!this.isBinary(expr, OP_CONCAT)) return undefined;
|
|
482
|
+
return this.getNumeral(this.manager.getArg(expr, 0)) === 0n
|
|
483
|
+
? this.manager.getArg(expr, 1)
|
|
484
|
+
: undefined;
|
|
485
|
+
}
|
|
486
|
+
|
|
487
|
+
private isSignExtended(expr: number) {
|
|
488
|
+
const manager = this.manager;
|
|
489
|
+
if (manager.getOp(expr) === OP_SIGN_EXT) return manager.getArg(expr, 0);
|
|
490
|
+
if (!this.isConcat(expr) || manager.getNumArgs(expr) < 2) return undefined;
|
|
491
|
+
const numArgs = manager.getNumArgs(expr);
|
|
492
|
+
const last = manager.getArg(expr, numArgs - 1);
|
|
493
|
+
const size = this.getSize(last);
|
|
494
|
+
for (let index = 0; index + 1 < numArgs; index++) {
|
|
495
|
+
const sign = manager.getArg(expr, index);
|
|
496
|
+
if (
|
|
497
|
+
!this.isExtract(sign) ||
|
|
498
|
+
this.getParameter(sign, 0) !== size - 1 ||
|
|
499
|
+
this.getParameter(sign, 1) !== size - 1 ||
|
|
500
|
+
manager.getArg(sign, 0) !== last
|
|
501
|
+
)
|
|
502
|
+
return undefined;
|
|
503
|
+
}
|
|
504
|
+
return last;
|
|
505
|
+
}
|
|
506
|
+
|
|
507
|
+
private mkLeqCore(isSigned: boolean, first: number, second: number): Result {
|
|
508
|
+
const manager = this.manager;
|
|
509
|
+
if (first === second) return manager.trueExpr;
|
|
510
|
+
const firstValue = this.getNumeral(first);
|
|
511
|
+
const secondValue = this.getNumeral(second);
|
|
512
|
+
const size = this.getSize(first);
|
|
513
|
+
if (isSigned) {
|
|
514
|
+
const firstInner = this.isZeroExtended(first);
|
|
515
|
+
const secondInner = this.isZeroExtended(second);
|
|
516
|
+
if (
|
|
517
|
+
firstInner !== undefined &&
|
|
518
|
+
secondInner !== undefined &&
|
|
519
|
+
this.getSize(firstInner) === this.getSize(secondInner)
|
|
520
|
+
)
|
|
521
|
+
return rewrite(this.app(OP_ULEQ, [firstInner, secondInner]), 2);
|
|
522
|
+
}
|
|
523
|
+
const first1 = firstValue === undefined ? undefined : this.norm(firstValue, size, isSigned);
|
|
524
|
+
const second1 = secondValue === undefined ? undefined : this.norm(secondValue, size, isSigned);
|
|
525
|
+
if (first1 !== undefined && second1 !== undefined)
|
|
526
|
+
return first1 <= second1 ? manager.trueExpr : manager.falseExpr;
|
|
527
|
+
const lower = isSigned ? -getPowerOfTwo(size - 1) : 0n;
|
|
528
|
+
const upper = isSigned ? getPowerOfTwo(size - 1) - 1n : getPowerOfTwo(size) - 1n;
|
|
529
|
+
if (second1 !== undefined) {
|
|
530
|
+
if (second1 === lower) return rewrite(manager.mkEq(first, second), 1);
|
|
531
|
+
if (second1 === upper) return manager.trueExpr;
|
|
532
|
+
}
|
|
533
|
+
if (first1 !== undefined) {
|
|
534
|
+
if (first1 === lower) return manager.trueExpr;
|
|
535
|
+
if (first1 === upper) return rewrite(manager.mkEq(first, second), 1);
|
|
536
|
+
}
|
|
537
|
+
if (isSigned && second1 !== undefined && this.isBinary(first, OP_BADD)) {
|
|
538
|
+
const summand = manager.getArg(first, 0);
|
|
539
|
+
const product = manager.getArg(first, 1);
|
|
540
|
+
const coefficient = this.isBinary(product, OP_BMUL)
|
|
541
|
+
? this.getNumeral(manager.getArg(product, 0))
|
|
542
|
+
: undefined;
|
|
543
|
+
const remainder = this.isBinary(product, OP_BMUL) ? manager.getArg(product, 1) : -1;
|
|
544
|
+
const divisor =
|
|
545
|
+
coefficient !== undefined && this.isBinary(remainder, OP_BSREM_I)
|
|
546
|
+
? this.getNumeral(manager.getArg(remainder, 1))
|
|
547
|
+
: undefined;
|
|
548
|
+
const divisorSize = divisor === undefined ? size : this.getSize(manager.getArg(remainder, 1));
|
|
549
|
+
if (
|
|
550
|
+
coefficient !== undefined &&
|
|
551
|
+
this.norm(coefficient, this.getSize(manager.getArg(product, 0)), true) === -1n &&
|
|
552
|
+
divisor !== undefined
|
|
553
|
+
) {
|
|
554
|
+
const signedDivisor = this.norm(divisor, divisorSize, true);
|
|
555
|
+
if (
|
|
556
|
+
signedDivisor > 0n &&
|
|
557
|
+
second1 > 0n &&
|
|
558
|
+
summand === manager.getArg(remainder, 0) &&
|
|
559
|
+
second1 % signedDivisor === 0n &&
|
|
560
|
+
signedDivisor + second1 - 1n < getPowerOfTwo(divisorSize - 1)
|
|
561
|
+
)
|
|
562
|
+
return rewrite(
|
|
563
|
+
this.app(OP_SLEQ, [summand, this.mkBv(signedDivisor + second1 - 1n, divisorSize)]),
|
|
564
|
+
2,
|
|
565
|
+
);
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
if (!isSigned && first1 !== undefined && this.isBinary(second, OP_BADD)) {
|
|
569
|
+
const offset = this.getNumeral(manager.getArg(second, 0));
|
|
570
|
+
if (offset !== undefined) {
|
|
571
|
+
const term = manager.getArg(second, 1);
|
|
572
|
+
const offsetSize = this.getSize(manager.getArg(second, 0));
|
|
573
|
+
const bound = this.app(OP_ULEQ, [term, this.mkBv(-offset - 1n, offsetSize)]);
|
|
574
|
+
if (first1 > offset)
|
|
575
|
+
return rewrite(
|
|
576
|
+
this.mkAndTerm([
|
|
577
|
+
bound,
|
|
578
|
+
this.app(OP_ULEQ, [this.mkBv(first1 - offset, offsetSize), term]),
|
|
579
|
+
]),
|
|
580
|
+
2,
|
|
581
|
+
);
|
|
582
|
+
if (first1 < offset)
|
|
583
|
+
return rewrite(
|
|
584
|
+
this.mkOrTerm([
|
|
585
|
+
bound,
|
|
586
|
+
this.app(OP_ULEQ, [this.mkBv(first1 - offset, offsetSize), term]),
|
|
587
|
+
]),
|
|
588
|
+
2,
|
|
589
|
+
);
|
|
590
|
+
return rewrite(bound, 2);
|
|
591
|
+
}
|
|
592
|
+
}
|
|
593
|
+
if (!isSigned) {
|
|
594
|
+
const getLastNonZero = (expr: number) => {
|
|
595
|
+
for (let index = size - 1; index >= 0; index--)
|
|
596
|
+
if (!this.isZeroBit(expr, index)) return index;
|
|
597
|
+
return -1;
|
|
598
|
+
};
|
|
599
|
+
const secondLast = getLastNonZero(second);
|
|
600
|
+
if (secondLast === -1) return rewrite(manager.mkEq(first, this.mkZero(size)), 1);
|
|
601
|
+
if (secondLast < size - 1) {
|
|
602
|
+
const high = this.mkExtractTerm(size - 1, secondLast + 1, first);
|
|
603
|
+
const zero = this.mkZero(size - secondLast - 1);
|
|
604
|
+
const firstLow = this.mkExtractTerm(secondLast, 0, first);
|
|
605
|
+
const secondLow = this.mkExtractTerm(secondLast, 0, second);
|
|
606
|
+
const comparison = this.app(OP_ULEQ, [firstLow, secondLow]);
|
|
607
|
+
return rewrite(this.mkAndTerm([manager.mkEq(high, zero), comparison]), 3);
|
|
608
|
+
}
|
|
609
|
+
const firstLast = getLastNonZero(first);
|
|
610
|
+
if (firstLast === -1) return manager.trueExpr;
|
|
611
|
+
if (firstLast < size - 1) {
|
|
612
|
+
const high = this.mkExtractTerm(size - 1, firstLast + 1, second);
|
|
613
|
+
const zero = this.mkZero(size - firstLast - 1);
|
|
614
|
+
const isHighZero = manager.mkEq(high, zero);
|
|
615
|
+
const firstLow = this.mkExtractTerm(firstLast, 0, first);
|
|
616
|
+
const secondLow = this.mkExtractTerm(firstLast, 0, second);
|
|
617
|
+
const comparison = this.app(OP_ULEQ, [firstLow, secondLow]);
|
|
618
|
+
return rewrite(manager.mkApp(OP_IMPLIES, [isHighZero, comparison], SORT_BOOL), 4);
|
|
619
|
+
}
|
|
620
|
+
}
|
|
621
|
+
return undefined;
|
|
622
|
+
}
|
|
623
|
+
|
|
624
|
+
private mkExtract(high: number, low: number, arg: number): Result {
|
|
625
|
+
const manager = this.manager;
|
|
626
|
+
const size = this.getSize(arg);
|
|
627
|
+
if (low === 0 && high === size - 1) return arg;
|
|
628
|
+
const value = this.getNumeral(arg);
|
|
629
|
+
if (value !== undefined)
|
|
630
|
+
return this.mkBv((value >> BigInt(low)) % getPowerOfTwo(high - low + 1), high - low + 1);
|
|
631
|
+
if (this.isExtract(arg)) {
|
|
632
|
+
const innerLow = this.getParameter(arg, 1);
|
|
633
|
+
return this.mkExtractTerm(high + innerLow, low + innerLow, manager.getArg(arg, 0));
|
|
634
|
+
}
|
|
635
|
+
if (this.isConcat(arg)) {
|
|
636
|
+
const numArgs = manager.getNumArgs(arg);
|
|
637
|
+
let position = size;
|
|
638
|
+
for (let index = 0; index < numArgs; index++) {
|
|
639
|
+
const current = manager.getArg(arg, index);
|
|
640
|
+
const currentSize = this.getSize(current);
|
|
641
|
+
position -= currentSize;
|
|
642
|
+
if (position > high) continue;
|
|
643
|
+
if (position <= low) {
|
|
644
|
+
if (low === position && high - position === currentSize - 1) return current;
|
|
645
|
+
return rewrite(this.mkExtractTerm(high - position, low - position, current), 1);
|
|
646
|
+
}
|
|
647
|
+
const newArgs: number[] = [];
|
|
648
|
+
let isExtracting = false;
|
|
649
|
+
if (high - position === currentSize - 1) newArgs.push(current);
|
|
650
|
+
else {
|
|
651
|
+
isExtracting = true;
|
|
652
|
+
newArgs.push(this.mkExtractTerm(high - position, 0, current));
|
|
653
|
+
}
|
|
654
|
+
for (let next = index + 1; next < numArgs; next++) {
|
|
655
|
+
const nextArg = manager.getArg(arg, next);
|
|
656
|
+
const nextSize = this.getSize(nextArg);
|
|
657
|
+
position -= nextSize;
|
|
658
|
+
if (position > low) {
|
|
659
|
+
newArgs.push(nextArg);
|
|
660
|
+
continue;
|
|
661
|
+
}
|
|
662
|
+
if (position === low) {
|
|
663
|
+
newArgs.push(nextArg);
|
|
664
|
+
const concat = this.mkConcatTerm(newArgs);
|
|
665
|
+
return isExtracting ? rewrite(concat, 2) : concat;
|
|
666
|
+
}
|
|
667
|
+
newArgs.push(this.mkExtractTerm(nextSize - 1, low - position, nextArg));
|
|
668
|
+
return rewrite(this.mkConcatTerm(newArgs), 2);
|
|
669
|
+
}
|
|
670
|
+
}
|
|
671
|
+
}
|
|
672
|
+
const op = manager.getOp(arg);
|
|
673
|
+
if (low === 0 && manager.kinds[arg] === KIND_APP && manager.getNumArgs(arg) === 2) {
|
|
674
|
+
const isUnsigned = op === OP_BUDIV_I || op === OP_BUREM_I;
|
|
675
|
+
const isSignedDivision = op === OP_BSDIV_I || op === OP_BSREM_I;
|
|
676
|
+
if (isUnsigned || isSignedDivision) {
|
|
677
|
+
const dividend = manager.getArg(arg, 0);
|
|
678
|
+
const divisor = manager.getArg(arg, 1);
|
|
679
|
+
const innerDividend = isUnsigned
|
|
680
|
+
? this.isZeroExtended(dividend)
|
|
681
|
+
: this.isSignExtended(dividend);
|
|
682
|
+
const innerDivisor =
|
|
683
|
+
innerDividend === undefined
|
|
684
|
+
? undefined
|
|
685
|
+
: isUnsigned
|
|
686
|
+
? this.isZeroExtended(divisor)
|
|
687
|
+
: this.isSignExtended(divisor);
|
|
688
|
+
if (
|
|
689
|
+
innerDividend !== undefined &&
|
|
690
|
+
innerDivisor !== undefined &&
|
|
691
|
+
high + 1 === this.getSize(innerDividend) &&
|
|
692
|
+
this.getSize(innerDividend) === this.getSize(innerDivisor)
|
|
693
|
+
)
|
|
694
|
+
return rewrite(this.app(op, [innerDividend, innerDivisor]), 1);
|
|
695
|
+
}
|
|
696
|
+
}
|
|
697
|
+
if (
|
|
698
|
+
op === OP_BNOT ||
|
|
699
|
+
op === OP_BOR ||
|
|
700
|
+
op === OP_BXOR ||
|
|
701
|
+
(low === 0 && (op === OP_BADD || op === OP_BMUL))
|
|
702
|
+
) {
|
|
703
|
+
const newArgs = manager.mapArgs(arg, (innerArg) => this.mkExtractTerm(high, low, innerArg));
|
|
704
|
+
return rewrite(this.app(op, newArgs), 2);
|
|
705
|
+
}
|
|
706
|
+
if (this.isIte(arg)) {
|
|
707
|
+
const thenExpr = manager.getArg(arg, 1);
|
|
708
|
+
const elseExpr = manager.getArg(arg, 2);
|
|
709
|
+
if (
|
|
710
|
+
manager.getRefCount(thenExpr) === 1 ||
|
|
711
|
+
manager.getRefCount(elseExpr) === 1 ||
|
|
712
|
+
!this.isIte(thenExpr) ||
|
|
713
|
+
!this.isIte(elseExpr)
|
|
714
|
+
) {
|
|
715
|
+
const thenExtract = this.mkExtractTerm(high, low, thenExpr);
|
|
716
|
+
const elseExtract = this.mkExtractTerm(high, low, elseExpr);
|
|
717
|
+
return rewrite(this.mkIteTerm(manager.getArg(arg, 0), thenExtract, elseExtract), 2);
|
|
718
|
+
}
|
|
719
|
+
}
|
|
720
|
+
if (low === 0 && this.isBinary(arg, OP_BASHR)) {
|
|
721
|
+
const shift = this.getNumeral(manager.getArg(arg, 1));
|
|
722
|
+
if (shift !== undefined && BigInt(high) < BigInt(size) - shift) {
|
|
723
|
+
const amount = Number(shift);
|
|
724
|
+
return rewrite(this.mkExtractTerm(high + amount, low + amount, manager.getArg(arg, 0)), 1);
|
|
725
|
+
}
|
|
726
|
+
}
|
|
727
|
+
return undefined;
|
|
728
|
+
}
|
|
729
|
+
|
|
730
|
+
private mkBvShl(first: number, second: number): Result {
|
|
731
|
+
const manager = this.manager;
|
|
732
|
+
const size = this.getSize(first);
|
|
733
|
+
const shift = this.getNumeral(second);
|
|
734
|
+
if (shift !== undefined) {
|
|
735
|
+
if (shift === 0n) return first;
|
|
736
|
+
if (shift >= BigInt(size)) return this.mkZero(size);
|
|
737
|
+
const value = this.getNumeral(first);
|
|
738
|
+
if (value !== undefined) return this.mkBv(value << shift, size);
|
|
739
|
+
const amount = Number(shift);
|
|
740
|
+
const kept = this.mkExtractTerm(size - amount - 1, 0, first);
|
|
741
|
+
return rewrite(this.mkConcatTerm([kept, this.mkZero(amount)]), 2);
|
|
742
|
+
}
|
|
743
|
+
if (this.isBinary(first, OP_BSHL)) {
|
|
744
|
+
const inner = manager.getArg(first, 0);
|
|
745
|
+
const innerShift = manager.getArg(first, 1);
|
|
746
|
+
const sum = this.app(OP_BADD, [innerShift, second]);
|
|
747
|
+
const condition = this.app(OP_ULEQ, [innerShift, sum]);
|
|
748
|
+
const shifted = this.app(OP_BSHL, [inner, sum]);
|
|
749
|
+
return rewrite(this.mkIteTerm(condition, shifted, this.mkZero(size)), 3);
|
|
750
|
+
}
|
|
751
|
+
return undefined;
|
|
752
|
+
}
|
|
753
|
+
|
|
754
|
+
private mkBvLshr(first: number, second: number): Result {
|
|
755
|
+
const size = this.getSize(first);
|
|
756
|
+
const shift = this.getNumeral(second);
|
|
757
|
+
if (shift !== undefined) {
|
|
758
|
+
if (shift === 0n) return first;
|
|
759
|
+
if (shift >= BigInt(size)) return this.mkZero(size);
|
|
760
|
+
const value = this.getNumeral(first);
|
|
761
|
+
if (value !== undefined) return this.mkBv(value >> shift, size);
|
|
762
|
+
const amount = Number(shift);
|
|
763
|
+
const zero = this.mkZero(amount);
|
|
764
|
+
return rewrite(this.mkConcatTerm([zero, this.mkExtractTerm(size - 1, amount, first)]), 2);
|
|
765
|
+
}
|
|
766
|
+
if (first === second) return this.mkZero(size);
|
|
767
|
+
return undefined;
|
|
768
|
+
}
|
|
769
|
+
|
|
770
|
+
private mkBvAshr(first: number, second: number): Result {
|
|
771
|
+
const manager = this.manager;
|
|
772
|
+
const size = this.getSize(first);
|
|
773
|
+
const shift = this.getNumeral(second);
|
|
774
|
+
if (shift === 0n) return first;
|
|
775
|
+
const value = this.getNumeral(first);
|
|
776
|
+
if (value !== undefined && shift !== undefined) {
|
|
777
|
+
const isNegative = this.hasSignBit(value, size);
|
|
778
|
+
if (shift >= BigInt(size)) return isNegative ? this.mkAllOnes(size) : this.mkZero(size);
|
|
779
|
+
const shifted = value >> shift;
|
|
780
|
+
const fill = isNegative ? getPowerOfTwo(size) - getPowerOfTwo(size - Number(shift)) : 0n;
|
|
781
|
+
return this.mkBv(shifted | fill, size);
|
|
782
|
+
}
|
|
783
|
+
if (shift !== undefined && this.isBinary(first, OP_BASHR)) {
|
|
784
|
+
const innerShift = this.getNumeral(manager.getArg(first, 1));
|
|
785
|
+
if (innerShift !== undefined) {
|
|
786
|
+
const total = innerShift + shift > BigInt(size) ? BigInt(size) : innerShift + shift;
|
|
787
|
+
return rewrite(this.app(OP_BASHR, [manager.getArg(first, 0), this.mkBv(total, size)]), 1);
|
|
788
|
+
}
|
|
789
|
+
}
|
|
790
|
+
if (shift !== undefined && this.getNumLeadingZeroBits(first) > 0) {
|
|
791
|
+
if (shift >= BigInt(size)) return this.mkZero(size);
|
|
792
|
+
const amount = Number(shift);
|
|
793
|
+
const zero = this.mkZero(amount);
|
|
794
|
+
return rewrite(this.mkConcatTerm([zero, this.mkExtractTerm(size - 1, amount, first)]), 2);
|
|
795
|
+
}
|
|
796
|
+
return undefined;
|
|
797
|
+
}
|
|
798
|
+
|
|
799
|
+
private mkDivisionByTerm(
|
|
800
|
+
first: number,
|
|
801
|
+
second: number,
|
|
802
|
+
isHiDiv0: boolean,
|
|
803
|
+
divisionOp: number,
|
|
804
|
+
byZeroOp: number,
|
|
805
|
+
): Result {
|
|
806
|
+
if (isHiDiv0) return this.app(divisionOp, [first, second]);
|
|
807
|
+
const isZero = this.manager.mkEq(second, this.mkZero(this.getSize(second)));
|
|
808
|
+
const byZero = this.app(byZeroOp, [first]);
|
|
809
|
+
return rewrite(this.mkIteTerm(isZero, byZero, this.app(divisionOp, [first, second])), 2);
|
|
810
|
+
}
|
|
811
|
+
|
|
812
|
+
private mkBvSdiv(first: number, second: number, isHiDiv0: boolean): Result {
|
|
813
|
+
const divisor = this.getNumeral(second);
|
|
814
|
+
if (divisor === undefined)
|
|
815
|
+
return this.mkDivisionByTerm(first, second, isHiDiv0, OP_BSDIV_I, OP_BSDIV0);
|
|
816
|
+
const size = this.getSize(second);
|
|
817
|
+
const signedDivisor = this.norm(divisor, size, true);
|
|
818
|
+
if (signedDivisor === 0n) {
|
|
819
|
+
if (!isHiDiv0) return rewrite(this.app(OP_BSDIV0, [first]), 1);
|
|
820
|
+
const isNegative = this.app(OP_SLT, [first, this.mkZero(size)]);
|
|
821
|
+
const one = this.mkOne(size);
|
|
822
|
+
return rewrite(this.mkIteTerm(isNegative, one, this.mkAllOnes(size)), 2);
|
|
823
|
+
}
|
|
824
|
+
if (signedDivisor === 1n) return first;
|
|
825
|
+
const dividend = this.getNumeral(first);
|
|
826
|
+
if (dividend !== undefined)
|
|
827
|
+
return this.mkBv(this.norm(dividend, size, true) / signedDivisor, size);
|
|
828
|
+
return this.app(OP_BSDIV_I, [first, second]);
|
|
829
|
+
}
|
|
830
|
+
|
|
831
|
+
private mkBvUdiv(first: number, second: number, isHiDiv0: boolean): Result {
|
|
832
|
+
const divisor = this.getNumeral(second);
|
|
833
|
+
if (divisor === undefined)
|
|
834
|
+
return this.mkDivisionByTerm(first, second, isHiDiv0, OP_BUDIV_I, OP_BUDIV0);
|
|
835
|
+
const size = this.getSize(second);
|
|
836
|
+
if (divisor === 0n)
|
|
837
|
+
return isHiDiv0 ? this.mkAllOnes(size) : rewrite(this.app(OP_BUDIV0, [first]), 1);
|
|
838
|
+
if (divisor === 1n) return first;
|
|
839
|
+
const dividend = this.getNumeral(first);
|
|
840
|
+
if (dividend !== undefined) return this.mkBv(dividend / divisor, size);
|
|
841
|
+
const shift = getPowerOfTwoExponent(divisor);
|
|
842
|
+
if (shift !== -1)
|
|
843
|
+
return rewrite(this.app(OP_BLSHR, [first, this.mkBv(BigInt(shift), size)]), 1);
|
|
844
|
+
return this.app(OP_BUDIV_I, [first, second]);
|
|
845
|
+
}
|
|
846
|
+
|
|
847
|
+
private mkBvSrem(first: number, second: number, isHiDiv0: boolean): Result {
|
|
848
|
+
const manager = this.manager;
|
|
849
|
+
const divisor = this.getNumeral(second);
|
|
850
|
+
if (divisor === undefined)
|
|
851
|
+
return this.mkDivisionByTerm(first, second, isHiDiv0, OP_BSREM_I, OP_BSREM0);
|
|
852
|
+
const size = this.getSize(second);
|
|
853
|
+
const signedDivisor = this.norm(divisor, size, true);
|
|
854
|
+
if (signedDivisor === 0n) return isHiDiv0 ? first : rewrite(this.app(OP_BSREM0, [first]), 1);
|
|
855
|
+
if (signedDivisor === 1n || signedDivisor === -1n) return this.mkZero(size);
|
|
856
|
+
if (this.isBinary(first, OP_BSREM_I)) {
|
|
857
|
+
const innerDivisor = this.getNumeral(manager.getArg(first, 1));
|
|
858
|
+
if (innerDivisor !== undefined) {
|
|
859
|
+
const signedInner = this.norm(innerDivisor, this.getSize(manager.getArg(first, 1)), true);
|
|
860
|
+
if (signedInner !== 0n && signedInner % signedDivisor === 0n)
|
|
861
|
+
return rewrite(this.app(OP_BSREM_I, [manager.getArg(first, 0), second]), 1);
|
|
862
|
+
}
|
|
863
|
+
}
|
|
864
|
+
const dividend = this.getNumeral(first);
|
|
865
|
+
if (dividend !== undefined)
|
|
866
|
+
return this.mkBv(this.norm(dividend, size, true) % signedDivisor, size);
|
|
867
|
+
return this.app(OP_BSREM_I, [first, second]);
|
|
868
|
+
}
|
|
869
|
+
|
|
870
|
+
private getXMinusOne(expr: number) {
|
|
871
|
+
const manager = this.manager;
|
|
872
|
+
if (!this.isAdd(expr) || manager.getNumArgs(expr) !== 2) return undefined;
|
|
873
|
+
if (this.isAllOnes(manager.getArg(expr, 0))) return manager.getArg(expr, 1);
|
|
874
|
+
if (this.isAllOnes(manager.getArg(expr, 1))) return manager.getArg(expr, 0);
|
|
875
|
+
return undefined;
|
|
876
|
+
}
|
|
877
|
+
|
|
878
|
+
private mkBvUrem(first: number, second: number, isHiDiv0: boolean): Result {
|
|
879
|
+
const manager = this.manager;
|
|
880
|
+
const dividend = this.getNumeral(first);
|
|
881
|
+
const divisor = this.getNumeral(second);
|
|
882
|
+
if (divisor !== undefined) {
|
|
883
|
+
const size = this.getSize(second);
|
|
884
|
+
if (divisor === 0n) return isHiDiv0 ? first : rewrite(this.app(OP_BUREM0, [first]), 1);
|
|
885
|
+
if (divisor === 1n) return this.mkZero(size);
|
|
886
|
+
if (dividend !== undefined) return this.mkBv(dividend % divisor, size);
|
|
887
|
+
const shift = getPowerOfTwoExponent(divisor);
|
|
888
|
+
if (shift !== -1) {
|
|
889
|
+
const zero = this.mkZero(size - shift);
|
|
890
|
+
return rewrite(this.mkConcatTerm([zero, this.mkExtractTerm(shift - 1, 0, first)]), 2);
|
|
891
|
+
}
|
|
892
|
+
return this.app(OP_BUREM_I, [first, second]);
|
|
893
|
+
}
|
|
894
|
+
const isMinusOne = this.getXMinusOne(first) === second;
|
|
895
|
+
if (isHiDiv0) {
|
|
896
|
+
if (dividend === 0n || isMinusOne) return first;
|
|
897
|
+
return this.app(OP_BUREM_I, [first, second]);
|
|
898
|
+
}
|
|
899
|
+
if (dividend === 0n) {
|
|
900
|
+
const isZero = manager.mkEq(second, first);
|
|
901
|
+
return rewrite(this.mkIteTerm(isZero, this.app(OP_BUREM0, [first]), first), 2);
|
|
902
|
+
}
|
|
903
|
+
if (isMinusOne) {
|
|
904
|
+
const size = this.getSize(first);
|
|
905
|
+
const minusOne = this.mkAllOnes(size);
|
|
906
|
+
const isZero = manager.mkEq(second, this.mkZero(size));
|
|
907
|
+
return rewrite(this.mkIteTerm(isZero, this.app(OP_BUREM0, [minusOne]), first), 2);
|
|
908
|
+
}
|
|
909
|
+
return this.mkDivisionByTerm(first, second, false, OP_BUREM_I, OP_BUREM0);
|
|
910
|
+
}
|
|
911
|
+
|
|
912
|
+
private mkBvSmod(first: number, second: number, isHiDiv0: boolean): Result {
|
|
913
|
+
const dividend = this.getNumeral(first);
|
|
914
|
+
const size = this.getSize(first);
|
|
915
|
+
const signedDividend = dividend === undefined ? undefined : this.norm(dividend, size, true);
|
|
916
|
+
if (signedDividend === 0n) return rewrite(this.app(OP_BUREM, [first, second]), 1);
|
|
917
|
+
const divisor = this.getNumeral(second);
|
|
918
|
+
if (divisor !== undefined) {
|
|
919
|
+
const signedDivisor = this.norm(divisor, size, true);
|
|
920
|
+
if (signedDivisor === 0n) return isHiDiv0 ? first : this.app(OP_BSMOD0, [first]);
|
|
921
|
+
if (signedDividend !== undefined) {
|
|
922
|
+
const remainder = this.norm(
|
|
923
|
+
this.norm(getAbs(signedDividend), size) % this.norm(getAbs(signedDivisor), size),
|
|
924
|
+
size,
|
|
925
|
+
);
|
|
926
|
+
const result =
|
|
927
|
+
remainder === 0n
|
|
928
|
+
? remainder
|
|
929
|
+
: signedDividend > 0n && signedDivisor > 0n
|
|
930
|
+
? remainder
|
|
931
|
+
: signedDividend < 0n && signedDivisor > 0n
|
|
932
|
+
? this.norm(signedDivisor - remainder, size)
|
|
933
|
+
: signedDividend > 0n && signedDivisor < 0n
|
|
934
|
+
? this.norm(remainder + signedDivisor, size)
|
|
935
|
+
: this.norm(-remainder, size);
|
|
936
|
+
return this.mkBv(result, size);
|
|
937
|
+
}
|
|
938
|
+
if (signedDivisor === 1n) return rewrite(this.mkZero(size), 2);
|
|
939
|
+
}
|
|
940
|
+
return this.mkDivisionByTerm(first, second, isHiDiv0, OP_BSMOD_I, OP_BSMOD0);
|
|
941
|
+
}
|
|
942
|
+
|
|
943
|
+
private mkInt2bv(size: number, arg: number): Result {
|
|
944
|
+
const manager = this.manager;
|
|
945
|
+
if (manager.isNumeral(arg) && manager.getRationalValue(arg).isInt())
|
|
946
|
+
return this.mkBv(manager.getRationalValue(arg).num, size);
|
|
947
|
+
if (manager.getOp(arg) !== OP_UBV2INT) return undefined;
|
|
948
|
+
const inner = manager.getArg(arg, 0);
|
|
949
|
+
const innerSize = this.getSize(inner);
|
|
950
|
+
if (size === innerSize) return inner;
|
|
951
|
+
if (size > innerSize)
|
|
952
|
+
return rewrite(this.getExpr(this.mkZeroExtend(size - innerSize, inner)), 1);
|
|
953
|
+
return rewrite(this.mkExtractTerm(size - 1, 0, inner), 1);
|
|
954
|
+
}
|
|
955
|
+
|
|
956
|
+
private mkSbv2intAsUbv2int(arg: number) {
|
|
957
|
+
const manager = this.manager;
|
|
958
|
+
const unsigned = this.app(OP_UBV2INT, [arg]);
|
|
959
|
+
const size = this.getSize(arg);
|
|
960
|
+
const zero = this.mkZero(size);
|
|
961
|
+
const isNegative = this.app(OP_SLT, [arg, zero]);
|
|
962
|
+
const difference = manager.mkApp(
|
|
963
|
+
OP_SUB,
|
|
964
|
+
[unsigned, manager.mkNumeral(getPowerOfTwo(size))],
|
|
965
|
+
SORT_INT,
|
|
966
|
+
);
|
|
967
|
+
return manager.mkApp(OP_ITE, [isNegative, difference, unsigned], SORT_INT);
|
|
968
|
+
}
|
|
969
|
+
|
|
970
|
+
private mkIntApp(op: number, args: number[]) {
|
|
971
|
+
return args.length === 1 ? args[0] : this.manager.mkApp(op, args, SORT_INT);
|
|
972
|
+
}
|
|
973
|
+
|
|
974
|
+
private mkUbv2int(arg: number): Result {
|
|
975
|
+
const manager = this.manager;
|
|
976
|
+
const value = this.getNumeral(arg);
|
|
977
|
+
if (value !== undefined) return manager.mkNumeral(value);
|
|
978
|
+
if (this.isConcat(arg)) {
|
|
979
|
+
const numArgs = manager.getNumArgs(arg);
|
|
980
|
+
const args = manager.mapArgs(arg, (innerArg) => this.app(OP_UBV2INT, [innerArg]));
|
|
981
|
+
let size = this.getSize(manager.getArg(arg, numArgs - 1));
|
|
982
|
+
for (let index = numArgs - 1; index > 0;) {
|
|
983
|
+
index--;
|
|
984
|
+
const factor = manager.mkNumeral(getPowerOfTwo(size));
|
|
985
|
+
args[index] = manager.mkApp(OP_MUL, [factor, args[index]], SORT_INT);
|
|
986
|
+
size += this.getSize(manager.getArg(arg, index));
|
|
987
|
+
}
|
|
988
|
+
return rewrite(this.mkIntApp(OP_ADD, args), 2);
|
|
989
|
+
}
|
|
990
|
+
if (this.isMulNoOverflow(arg))
|
|
991
|
+
return rewrite(
|
|
992
|
+
this.mkIntApp(
|
|
993
|
+
OP_MUL,
|
|
994
|
+
manager.mapArgs(arg, (innerArg) => this.app(OP_UBV2INT, [innerArg])),
|
|
995
|
+
),
|
|
996
|
+
2,
|
|
997
|
+
);
|
|
998
|
+
if (this.isAddNoOverflow(arg))
|
|
999
|
+
return rewrite(
|
|
1000
|
+
this.mkIntApp(
|
|
1001
|
+
OP_ADD,
|
|
1002
|
+
manager.mapArgs(arg, (innerArg) => this.app(OP_UBV2INT, [innerArg])),
|
|
1003
|
+
),
|
|
1004
|
+
2,
|
|
1005
|
+
);
|
|
1006
|
+
return undefined;
|
|
1007
|
+
}
|
|
1008
|
+
|
|
1009
|
+
private isMulNoOverflow(expr: number) {
|
|
1010
|
+
const manager = this.manager;
|
|
1011
|
+
if (!this.isMul(expr)) return false;
|
|
1012
|
+
const size = this.getSize(expr);
|
|
1013
|
+
let sum = 0;
|
|
1014
|
+
for (let index = 0; index < manager.getNumArgs(expr); index++)
|
|
1015
|
+
sum += size - this.getNumLeadingZeroBits(manager.getArg(expr, index));
|
|
1016
|
+
if (sum > size + 1) return false;
|
|
1017
|
+
if (sum <= size) return true;
|
|
1018
|
+
return manager.someArg(expr, (arg) => {
|
|
1019
|
+
const value = this.getNumeral(arg);
|
|
1020
|
+
return value !== undefined && getPowerOfTwoExponent(value) !== -1;
|
|
1021
|
+
});
|
|
1022
|
+
}
|
|
1023
|
+
|
|
1024
|
+
private isAddNoOverflow(expr: number) {
|
|
1025
|
+
const manager = this.manager;
|
|
1026
|
+
if (!this.isAdd(expr)) return false;
|
|
1027
|
+
const numArgs = manager.getNumArgs(expr);
|
|
1028
|
+
if (numArgs <= 1) return true;
|
|
1029
|
+
return !manager.someArg(expr, (arg) => numArgs - 2 >= this.getNumLeadingZeroBits(arg));
|
|
1030
|
+
}
|
|
1031
|
+
|
|
1032
|
+
private getNumLeadingZeroBits(expr: number): number {
|
|
1033
|
+
const manager = this.manager;
|
|
1034
|
+
const value = this.getNumeral(expr);
|
|
1035
|
+
const size = this.getSize(expr);
|
|
1036
|
+
if (value !== undefined) return value === 0n ? size : size - value.toString(2).length;
|
|
1037
|
+
if (this.isConcat(expr)) {
|
|
1038
|
+
const head = manager.getArg(expr, 0);
|
|
1039
|
+
const headZeros = this.getNumLeadingZeroBits(head);
|
|
1040
|
+
return headZeros === this.getSize(head)
|
|
1041
|
+
? headZeros + this.getNumLeadingZeroBits(manager.getArg(expr, 1))
|
|
1042
|
+
: headZeros;
|
|
1043
|
+
}
|
|
1044
|
+
return 0;
|
|
1045
|
+
}
|
|
1046
|
+
|
|
1047
|
+
private mkConcat(args: number[]): Result {
|
|
1048
|
+
const manager = this.manager;
|
|
1049
|
+
const newArgs: number[] = [];
|
|
1050
|
+
let isFusedNumeral = false;
|
|
1051
|
+
let isExpanded = false;
|
|
1052
|
+
let isFusedExtract = false;
|
|
1053
|
+
let areEqual = true;
|
|
1054
|
+
for (let index = 0; index < args.length; index++) {
|
|
1055
|
+
const arg = args[index];
|
|
1056
|
+
const previous = index > 0 ? newArgs[newArgs.length - 1] : -1;
|
|
1057
|
+
if (index > 0) areEqual &&= previous === arg;
|
|
1058
|
+
const value = this.getNumeral(arg);
|
|
1059
|
+
const previousValue = previous === -1 ? undefined : this.getNumeral(previous);
|
|
1060
|
+
if (value !== undefined && previousValue !== undefined) {
|
|
1061
|
+
const argSize = this.getSize(arg);
|
|
1062
|
+
newArgs.pop();
|
|
1063
|
+
newArgs.push(
|
|
1064
|
+
this.mkBv(
|
|
1065
|
+
previousValue * getPowerOfTwo(argSize) + value,
|
|
1066
|
+
argSize + this.getSize(previous),
|
|
1067
|
+
),
|
|
1068
|
+
);
|
|
1069
|
+
isFusedNumeral = true;
|
|
1070
|
+
} else if (this.options.isFlat !== false && this.isConcat(arg)) {
|
|
1071
|
+
manager.pushArgs(arg, newArgs);
|
|
1072
|
+
isExpanded = true;
|
|
1073
|
+
} else if (
|
|
1074
|
+
this.isExtract(arg) &&
|
|
1075
|
+
previous !== -1 &&
|
|
1076
|
+
this.isExtract(previous) &&
|
|
1077
|
+
manager.getArg(arg, 0) === manager.getArg(previous, 0) &&
|
|
1078
|
+
this.getParameter(previous, 1) === this.getParameter(arg, 0) + 1
|
|
1079
|
+
) {
|
|
1080
|
+
const fused = this.mkExtractTerm(
|
|
1081
|
+
this.getParameter(previous, 0),
|
|
1082
|
+
this.getParameter(arg, 1),
|
|
1083
|
+
manager.getArg(arg, 0),
|
|
1084
|
+
);
|
|
1085
|
+
newArgs.pop();
|
|
1086
|
+
newArgs.push(fused);
|
|
1087
|
+
isFusedExtract = true;
|
|
1088
|
+
} else newArgs.push(arg);
|
|
1089
|
+
}
|
|
1090
|
+
if (!isFusedNumeral && !isExpanded && !isFusedExtract) {
|
|
1091
|
+
const last = newArgs[newArgs.length - 1];
|
|
1092
|
+
if (areEqual && this.isIte(last)) {
|
|
1093
|
+
const thenArgs = newArgs.map(() => manager.getArg(last, 1));
|
|
1094
|
+
const elseArgs = newArgs.map(() => manager.getArg(last, 2));
|
|
1095
|
+
const thenConcat = this.mkConcatTerm(thenArgs);
|
|
1096
|
+
const elseConcat = this.mkConcatTerm(elseArgs);
|
|
1097
|
+
return rewrite(this.mkIteTerm(manager.getArg(last, 0), thenConcat, elseConcat), 2);
|
|
1098
|
+
}
|
|
1099
|
+
return undefined;
|
|
1100
|
+
}
|
|
1101
|
+
if (newArgs.length === 1) return isFusedExtract ? rewrite(newArgs[0], 1) : newArgs[0];
|
|
1102
|
+
const result = this.mkConcatTerm(newArgs);
|
|
1103
|
+
return isFusedExtract ? rewrite(result, 2) : isExpanded ? rewrite(result, 1) : result;
|
|
1104
|
+
}
|
|
1105
|
+
|
|
1106
|
+
private factorZeroExtensions(op: number, args: number[]) {
|
|
1107
|
+
if (args.length < 2) return undefined;
|
|
1108
|
+
const first = this.isZeroExtended(args[0]);
|
|
1109
|
+
if (first === undefined) return undefined;
|
|
1110
|
+
const innerSize = this.getSize(first);
|
|
1111
|
+
const innerArgs = [first];
|
|
1112
|
+
for (let index = 1; index < args.length; index++) {
|
|
1113
|
+
const inner = this.isZeroExtended(args[index]);
|
|
1114
|
+
if (inner === undefined || this.getSize(inner) !== innerSize) return undefined;
|
|
1115
|
+
innerArgs.push(inner);
|
|
1116
|
+
}
|
|
1117
|
+
const inner = this.app(op, innerArgs);
|
|
1118
|
+
return this.app(OP_ZERO_EXT, [inner], [this.getSize(args[0]) - innerSize]);
|
|
1119
|
+
}
|
|
1120
|
+
|
|
1121
|
+
private mkZeroExtend(amount: number, arg: number): number | Rewrite {
|
|
1122
|
+
if (amount === 0) return arg;
|
|
1123
|
+
return rewrite(this.mkConcatTerm([this.mkZero(amount), arg]), 1);
|
|
1124
|
+
}
|
|
1125
|
+
|
|
1126
|
+
private mkSignExtend(amount: number, arg: number): Result {
|
|
1127
|
+
if (amount === 0) return arg;
|
|
1128
|
+
const value = this.getNumeral(arg);
|
|
1129
|
+
const size = this.getSize(arg);
|
|
1130
|
+
if (value !== undefined) return this.mkBv(this.norm(value, size, true), size + amount);
|
|
1131
|
+
const sign = this.mkExtractTerm(size - 1, size - 1, arg);
|
|
1132
|
+
const args = Array.from({ length: amount }, () => sign);
|
|
1133
|
+
args.push(arg);
|
|
1134
|
+
return rewrite(this.mkConcatTerm(args), 2);
|
|
1135
|
+
}
|
|
1136
|
+
|
|
1137
|
+
private isSorted(args: number[]) {
|
|
1138
|
+
for (let index = 1; index < args.length; index++)
|
|
1139
|
+
if (isAstLess(this.manager, args[index], args[index - 1])) return false;
|
|
1140
|
+
return true;
|
|
1141
|
+
}
|
|
1142
|
+
|
|
1143
|
+
private sortByAst(args: number[]) {
|
|
1144
|
+
args.sort((first, second) =>
|
|
1145
|
+
isAstLess(this.manager, first, second) ? -1 : isAstLess(this.manager, second, first) ? 1 : 0,
|
|
1146
|
+
);
|
|
1147
|
+
}
|
|
1148
|
+
|
|
1149
|
+
private flattenAc(op: number, args: number[]) {
|
|
1150
|
+
if (this.options.isFlat === false || !args.some((arg) => this.manager.getOp(arg) === op))
|
|
1151
|
+
return args;
|
|
1152
|
+
const flat: number[] = [];
|
|
1153
|
+
for (const arg of args)
|
|
1154
|
+
if (this.manager.getOp(arg) === op) this.manager.pushArgs(arg, flat);
|
|
1155
|
+
else flat.push(arg);
|
|
1156
|
+
return flat;
|
|
1157
|
+
}
|
|
1158
|
+
|
|
1159
|
+
private mkBvOr(inputArgs: number[]): Result {
|
|
1160
|
+
const manager = this.manager;
|
|
1161
|
+
if (inputArgs.length === 1) return inputArgs[0];
|
|
1162
|
+
const factored = this.factorZeroExtensions(OP_BOR, inputArgs);
|
|
1163
|
+
if (factored !== undefined) return rewrite(factored, 2);
|
|
1164
|
+
const size = this.getSize(inputArgs[0]);
|
|
1165
|
+
const args = this.flattenAc(OP_BOR, inputArgs);
|
|
1166
|
+
const isFlattened = args.length !== inputArgs.length;
|
|
1167
|
+
const newArgs: number[] = [];
|
|
1168
|
+
const positive = new Set<number>();
|
|
1169
|
+
const negative = new Set<number>();
|
|
1170
|
+
let isMerged = false;
|
|
1171
|
+
let numCoeffs = 0;
|
|
1172
|
+
let constant = 0n;
|
|
1173
|
+
const allOnes = getPowerOfTwo(size) - 1n;
|
|
1174
|
+
for (const arg of args) {
|
|
1175
|
+
const value = this.getNumeral(arg);
|
|
1176
|
+
if (value !== undefined) {
|
|
1177
|
+
numCoeffs++;
|
|
1178
|
+
constant |= value;
|
|
1179
|
+
continue;
|
|
1180
|
+
}
|
|
1181
|
+
if (manager.getOp(arg) === OP_BNOT) {
|
|
1182
|
+
const atom = manager.getArg(arg, 0);
|
|
1183
|
+
if (positive.has(atom)) return this.mkBv(allOnes, size);
|
|
1184
|
+
if (negative.has(atom)) {
|
|
1185
|
+
isMerged = true;
|
|
1186
|
+
continue;
|
|
1187
|
+
}
|
|
1188
|
+
negative.add(atom);
|
|
1189
|
+
newArgs.push(arg);
|
|
1190
|
+
} else {
|
|
1191
|
+
if (positive.has(arg)) {
|
|
1192
|
+
isMerged = true;
|
|
1193
|
+
continue;
|
|
1194
|
+
}
|
|
1195
|
+
if (negative.has(arg)) return this.mkBv(allOnes, size);
|
|
1196
|
+
positive.add(arg);
|
|
1197
|
+
newArgs.push(arg);
|
|
1198
|
+
}
|
|
1199
|
+
}
|
|
1200
|
+
if (constant === allOnes) return this.mkBv(constant, size);
|
|
1201
|
+
if (
|
|
1202
|
+
newArgs.length === 2 &&
|
|
1203
|
+
numCoeffs === 0 &&
|
|
1204
|
+
this.isConcat(newArgs[0]) &&
|
|
1205
|
+
this.isConcat(newArgs[1])
|
|
1206
|
+
) {
|
|
1207
|
+
const [first, second] = newArgs;
|
|
1208
|
+
let index = 0;
|
|
1209
|
+
while (index < size && (this.isZeroBit(first, index) || this.isZeroBit(second, index)))
|
|
1210
|
+
index++;
|
|
1211
|
+
if (index === size) {
|
|
1212
|
+
const parts: number[] = [];
|
|
1213
|
+
let position = size - 1;
|
|
1214
|
+
while (position >= 0) {
|
|
1215
|
+
let high = position;
|
|
1216
|
+
while (position >= 0 && this.isZeroBit(first, position)) position--;
|
|
1217
|
+
if (position !== high) parts.push(this.mkExtractTerm(high, position + 1, second));
|
|
1218
|
+
high = position;
|
|
1219
|
+
while (position >= 0 && this.isZeroBit(second, position)) position--;
|
|
1220
|
+
if (position !== high) parts.push(this.mkExtractTerm(high, position + 1, first));
|
|
1221
|
+
}
|
|
1222
|
+
return rewrite(this.mkConcatTerm(parts), 2);
|
|
1223
|
+
}
|
|
1224
|
+
}
|
|
1225
|
+
if (constant !== 0n && newArgs.length === 1) {
|
|
1226
|
+
const term = newArgs[0];
|
|
1227
|
+
let mask = constant;
|
|
1228
|
+
const parts: number[] = [];
|
|
1229
|
+
let low = 0;
|
|
1230
|
+
let index = 0;
|
|
1231
|
+
while (index < size) {
|
|
1232
|
+
while (index < size && mask % 2n === 1n) {
|
|
1233
|
+
index++;
|
|
1234
|
+
mask /= 2n;
|
|
1235
|
+
}
|
|
1236
|
+
if (index !== low) {
|
|
1237
|
+
parts.push(this.mkBv(getPowerOfTwo(index - low) - 1n, index - low));
|
|
1238
|
+
low = index;
|
|
1239
|
+
}
|
|
1240
|
+
while (index < size && mask % 2n === 0n) {
|
|
1241
|
+
index++;
|
|
1242
|
+
mask /= 2n;
|
|
1243
|
+
}
|
|
1244
|
+
if (index !== low) {
|
|
1245
|
+
parts.push(this.mkExtractTerm(index - 1, low, term));
|
|
1246
|
+
low = index;
|
|
1247
|
+
}
|
|
1248
|
+
}
|
|
1249
|
+
parts.reverse();
|
|
1250
|
+
return rewrite(this.mkConcatTerm(parts), 2);
|
|
1251
|
+
}
|
|
1252
|
+
if (
|
|
1253
|
+
!isFlattened &&
|
|
1254
|
+
!isMerged &&
|
|
1255
|
+
(numCoeffs === 0 || (numCoeffs === 1 && constant !== 0n)) &&
|
|
1256
|
+
this.isSorted(args)
|
|
1257
|
+
)
|
|
1258
|
+
return undefined;
|
|
1259
|
+
if (constant !== 0n) newArgs.push(this.mkBv(constant, size));
|
|
1260
|
+
if (newArgs.length === 0) return this.mkZero(size);
|
|
1261
|
+
if (newArgs.length === 1) return newArgs[0];
|
|
1262
|
+
this.sortByAst(newArgs);
|
|
1263
|
+
const distributed = this.distributeConcat(OP_BOR, newArgs);
|
|
1264
|
+
if (distributed !== undefined) return rewrite(distributed, 3);
|
|
1265
|
+
return this.app(OP_BOR, newArgs);
|
|
1266
|
+
}
|
|
1267
|
+
|
|
1268
|
+
private mkBvXor(inputArgs: number[]): Result {
|
|
1269
|
+
const manager = this.manager;
|
|
1270
|
+
if (inputArgs.length === 1) return inputArgs[0];
|
|
1271
|
+
const size = this.getSize(inputArgs[0]);
|
|
1272
|
+
const args = this.flattenAc(OP_BXOR, inputArgs);
|
|
1273
|
+
const isFlattened = args.length !== inputArgs.length;
|
|
1274
|
+
const positive = new Set<number>();
|
|
1275
|
+
const negative = new Set<number>();
|
|
1276
|
+
let isMerged = false;
|
|
1277
|
+
let numCoeffs = 0;
|
|
1278
|
+
let constant = 0n;
|
|
1279
|
+
const allOnes = getPowerOfTwo(size) - 1n;
|
|
1280
|
+
for (const arg of args) {
|
|
1281
|
+
const value = this.getNumeral(arg);
|
|
1282
|
+
if (value !== undefined) {
|
|
1283
|
+
constant ^= value;
|
|
1284
|
+
numCoeffs++;
|
|
1285
|
+
continue;
|
|
1286
|
+
}
|
|
1287
|
+
const isNot = manager.getOp(arg) === OP_BNOT;
|
|
1288
|
+
const atom = isNot ? manager.getArg(arg, 0) : arg;
|
|
1289
|
+
const same = isNot ? negative : positive;
|
|
1290
|
+
const other = isNot ? positive : negative;
|
|
1291
|
+
if (same.has(atom)) {
|
|
1292
|
+
same.delete(atom);
|
|
1293
|
+
isMerged = true;
|
|
1294
|
+
} else if (other.has(atom)) {
|
|
1295
|
+
other.delete(atom);
|
|
1296
|
+
isMerged = true;
|
|
1297
|
+
constant ^= allOnes;
|
|
1298
|
+
} else same.add(atom);
|
|
1299
|
+
}
|
|
1300
|
+
if (constant !== 0n && numCoeffs === args.length - 1) {
|
|
1301
|
+
let term = -1;
|
|
1302
|
+
for (const arg of args) {
|
|
1303
|
+
term = arg;
|
|
1304
|
+
if (!this.isNumeral(arg)) break;
|
|
1305
|
+
}
|
|
1306
|
+
let mask = constant;
|
|
1307
|
+
const parts: number[] = [];
|
|
1308
|
+
const notTerm = this.mkNotTerm(term);
|
|
1309
|
+
let low = 0;
|
|
1310
|
+
let index = 0;
|
|
1311
|
+
while (index < size) {
|
|
1312
|
+
while (index < size && mask % 2n === 1n) {
|
|
1313
|
+
index++;
|
|
1314
|
+
mask /= 2n;
|
|
1315
|
+
}
|
|
1316
|
+
if (index !== low) {
|
|
1317
|
+
parts.push(this.mkExtractTerm(index - 1, low, notTerm));
|
|
1318
|
+
low = index;
|
|
1319
|
+
}
|
|
1320
|
+
while (index < size && mask % 2n === 0n) {
|
|
1321
|
+
index++;
|
|
1322
|
+
mask /= 2n;
|
|
1323
|
+
}
|
|
1324
|
+
if (index !== low) {
|
|
1325
|
+
parts.push(this.mkExtractTerm(index - 1, low, term));
|
|
1326
|
+
low = index;
|
|
1327
|
+
}
|
|
1328
|
+
}
|
|
1329
|
+
parts.reverse();
|
|
1330
|
+
return rewrite(parts.length === 1 ? parts[0] : this.mkConcatTerm(parts), 3);
|
|
1331
|
+
}
|
|
1332
|
+
if (
|
|
1333
|
+
!isMerged &&
|
|
1334
|
+
!isFlattened &&
|
|
1335
|
+
(numCoeffs === 0 || (numCoeffs === 1 && constant !== 0n && constant !== allOnes)) &&
|
|
1336
|
+
this.isSorted(args)
|
|
1337
|
+
) {
|
|
1338
|
+
const distributed = this.distributeConcat(OP_BXOR, args);
|
|
1339
|
+
return distributed === undefined ? undefined : rewrite(distributed, 3);
|
|
1340
|
+
}
|
|
1341
|
+
const newArgs: number[] = constant === 0n ? [] : [this.mkBv(constant, size)];
|
|
1342
|
+
for (const arg of args) {
|
|
1343
|
+
if (this.isNumeral(arg)) continue;
|
|
1344
|
+
if (manager.getOp(arg) === OP_BNOT) {
|
|
1345
|
+
const atom = manager.getArg(arg, 0);
|
|
1346
|
+
if (negative.has(atom)) {
|
|
1347
|
+
newArgs.push(arg);
|
|
1348
|
+
negative.delete(atom);
|
|
1349
|
+
}
|
|
1350
|
+
} else if (positive.has(arg)) {
|
|
1351
|
+
newArgs.push(arg);
|
|
1352
|
+
positive.delete(arg);
|
|
1353
|
+
}
|
|
1354
|
+
}
|
|
1355
|
+
if (newArgs.length === 0) return this.mkZero(size);
|
|
1356
|
+
if (newArgs.length === 1) return newArgs[0];
|
|
1357
|
+
if (newArgs.length === 2 && this.isAllOnes(newArgs[0])) return this.mkNotTerm(newArgs[1]);
|
|
1358
|
+
this.sortByAst(newArgs);
|
|
1359
|
+
const distributed = this.distributeConcat(OP_BXOR, newArgs);
|
|
1360
|
+
if (distributed !== undefined) return rewrite(distributed, 3);
|
|
1361
|
+
return this.app(OP_BXOR, newArgs);
|
|
1362
|
+
}
|
|
1363
|
+
|
|
1364
|
+
private distributeConcat(op: number, args: number[]) {
|
|
1365
|
+
const manager = this.manager;
|
|
1366
|
+
for (const arg of args) {
|
|
1367
|
+
if (!this.isConcat(arg)) continue;
|
|
1368
|
+
const headSize = this.getSize(manager.getArg(arg, 0));
|
|
1369
|
+
const size = this.getSize(arg);
|
|
1370
|
+
if (headSize === size) return this.app(op, args);
|
|
1371
|
+
const highArgs: number[] = [];
|
|
1372
|
+
const lowArgs: number[] = [];
|
|
1373
|
+
for (const innerArg of args) {
|
|
1374
|
+
highArgs.push(this.mkExtractTerm(size - 1, size - headSize, innerArg));
|
|
1375
|
+
lowArgs.push(this.mkExtractTerm(size - headSize - 1, 0, innerArg));
|
|
1376
|
+
}
|
|
1377
|
+
const high = this.app(op, highArgs);
|
|
1378
|
+
return this.mkConcatTerm([high, this.app(op, lowArgs)]);
|
|
1379
|
+
}
|
|
1380
|
+
return undefined;
|
|
1381
|
+
}
|
|
1382
|
+
|
|
1383
|
+
private mkBvNot(arg: number): Result {
|
|
1384
|
+
const manager = this.manager;
|
|
1385
|
+
if (manager.getOp(arg) === OP_BNOT) return manager.getArg(arg, 0);
|
|
1386
|
+
const value = this.getNumeral(arg);
|
|
1387
|
+
const size = this.getSize(arg);
|
|
1388
|
+
if (value !== undefined) return this.mkBv(getPowerOfTwo(size) - 1n - value, size);
|
|
1389
|
+
if (this.isConcat(arg))
|
|
1390
|
+
return rewrite(
|
|
1391
|
+
this.mkConcatTerm(manager.mapArgs(arg, (innerArg) => this.mkNotTerm(innerArg))),
|
|
1392
|
+
2,
|
|
1393
|
+
);
|
|
1394
|
+
if (this.isIte(arg)) {
|
|
1395
|
+
const thenValue = this.getNumeral(manager.getArg(arg, 1));
|
|
1396
|
+
if (thenValue !== undefined) {
|
|
1397
|
+
const thenNot = this.mkBv(getPowerOfTwo(size) - 1n - thenValue, size);
|
|
1398
|
+
const elseNot = this.mkNotTerm(manager.getArg(arg, 2));
|
|
1399
|
+
return rewrite(this.mkIteTerm(manager.getArg(arg, 0), thenNot, elseNot), 2);
|
|
1400
|
+
}
|
|
1401
|
+
const elseValue = this.getNumeral(manager.getArg(arg, 2));
|
|
1402
|
+
if (elseValue !== undefined) {
|
|
1403
|
+
const thenNot = this.mkNotTerm(manager.getArg(arg, 1));
|
|
1404
|
+
const elseNot = this.mkBv(getPowerOfTwo(size) - 1n - elseValue, size);
|
|
1405
|
+
return rewrite(this.mkIteTerm(manager.getArg(arg, 0), thenNot, elseNot), 2);
|
|
1406
|
+
}
|
|
1407
|
+
}
|
|
1408
|
+
return undefined;
|
|
1409
|
+
}
|
|
1410
|
+
|
|
1411
|
+
private mkBvAnd(args: number[]): Result {
|
|
1412
|
+
const factored = this.factorZeroExtensions(OP_BAND, args);
|
|
1413
|
+
if (factored !== undefined) return rewrite(factored, 2);
|
|
1414
|
+
const negations = args.map((arg) => this.mkNotTerm(arg));
|
|
1415
|
+
return rewrite(this.mkNotTerm(this.app(OP_BOR, negations)), 3);
|
|
1416
|
+
}
|
|
1417
|
+
|
|
1418
|
+
private mkBvXnor(args: number[]): Result {
|
|
1419
|
+
const manager = this.manager;
|
|
1420
|
+
if (args.length === 0) return rewrite(manager.trueExpr, 2);
|
|
1421
|
+
if (args.length === 1) return rewrite(this.mkNotTerm(args[0]), 2);
|
|
1422
|
+
let result = this.mkNotTerm(this.app(OP_BXOR, [args[0], args[1]]));
|
|
1423
|
+
if (args.length === 2) return rewrite(result, 2);
|
|
1424
|
+
for (let index = 2; index < args.length; index++)
|
|
1425
|
+
result = this.mkNotTerm(this.app(OP_BXOR, [result, args[index]]));
|
|
1426
|
+
return rewrite(result, 4);
|
|
1427
|
+
}
|
|
1428
|
+
|
|
1429
|
+
private mkRotateLeft(amount: number, arg: number): Result {
|
|
1430
|
+
const size = this.getSize(arg);
|
|
1431
|
+
const shift = amount % size;
|
|
1432
|
+
if (shift === 0 || size === 1) return arg;
|
|
1433
|
+
const low = this.mkExtractTerm(size - shift - 1, 0, arg);
|
|
1434
|
+
return rewrite(this.mkConcatTerm([low, this.mkExtractTerm(size - 1, size - shift, arg)]), 2);
|
|
1435
|
+
}
|
|
1436
|
+
|
|
1437
|
+
private mkRotateRight(amount: number, arg: number) {
|
|
1438
|
+
const size = this.getSize(arg);
|
|
1439
|
+
return this.mkRotateLeft(size - (amount % size), arg);
|
|
1440
|
+
}
|
|
1441
|
+
|
|
1442
|
+
private mkExtRotate(isLeft: boolean, first: number, second: number): Result {
|
|
1443
|
+
const manager = this.manager;
|
|
1444
|
+
const amount = this.getNumeral(second);
|
|
1445
|
+
if (amount !== undefined) {
|
|
1446
|
+
const size = BigInt(this.getSize(first));
|
|
1447
|
+
const shift = Number(amount % size);
|
|
1448
|
+
return isLeft ? this.mkRotateLeft(shift, first) : this.mkRotateRight(shift, first);
|
|
1449
|
+
}
|
|
1450
|
+
const op = isLeft ? OP_EXT_ROTATE_LEFT : OP_EXT_ROTATE_RIGHT;
|
|
1451
|
+
const opposite = isLeft ? OP_EXT_ROTATE_RIGHT : OP_EXT_ROTATE_LEFT;
|
|
1452
|
+
if (this.isBinary(first, opposite) && manager.getArg(first, 1) === second)
|
|
1453
|
+
return manager.getArg(first, 0);
|
|
1454
|
+
if (this.isBinary(first, op)) {
|
|
1455
|
+
const total = this.app(OP_BADD, [manager.getArg(first, 1), second]);
|
|
1456
|
+
return rewrite(this.app(op, [manager.getArg(first, 0), total]), 2);
|
|
1457
|
+
}
|
|
1458
|
+
if (this.isBinary(first, opposite)) {
|
|
1459
|
+
const difference = this.app(OP_BSUB, [second, manager.getArg(first, 1)]);
|
|
1460
|
+
return rewrite(this.app(op, [manager.getArg(first, 0), difference]), 2);
|
|
1461
|
+
}
|
|
1462
|
+
return undefined;
|
|
1463
|
+
}
|
|
1464
|
+
|
|
1465
|
+
private mkBvAdd(args: number[]): Result {
|
|
1466
|
+
const result = this.mkAddCore(args);
|
|
1467
|
+
if (result !== undefined && typeof result !== "number") return result;
|
|
1468
|
+
const sumArgs =
|
|
1469
|
+
result === undefined ? args : this.isAdd(result) ? this.manager.getArgs(result) : undefined;
|
|
1470
|
+
if (sumArgs === undefined || sumArgs.length < 2) return result;
|
|
1471
|
+
const size = this.getSize(sumArgs[0]);
|
|
1472
|
+
for (let index = 0; index < size; index++) {
|
|
1473
|
+
let isNonZero = false;
|
|
1474
|
+
for (const arg of sumArgs) {
|
|
1475
|
+
if (this.isZeroBit(arg, index)) continue;
|
|
1476
|
+
if (isNonZero) return result;
|
|
1477
|
+
isNonZero = true;
|
|
1478
|
+
}
|
|
1479
|
+
}
|
|
1480
|
+
return rewrite(this.app(OP_BOR, sumArgs), 1);
|
|
1481
|
+
}
|
|
1482
|
+
|
|
1483
|
+
private isZeroBit(inputExpr: number, inputIndex: number) {
|
|
1484
|
+
const manager = this.manager;
|
|
1485
|
+
let expr = inputExpr;
|
|
1486
|
+
let index = inputIndex;
|
|
1487
|
+
for (;;) {
|
|
1488
|
+
const value = this.getNumeral(expr);
|
|
1489
|
+
if (value !== undefined) return ((value >> BigInt(index)) & 1n) === 0n;
|
|
1490
|
+
if (!this.isConcat(expr)) return false;
|
|
1491
|
+
let position = manager.getNumArgs(expr);
|
|
1492
|
+
for (;;) {
|
|
1493
|
+
position--;
|
|
1494
|
+
const arg = manager.getArg(expr, position);
|
|
1495
|
+
const size = this.getSize(arg);
|
|
1496
|
+
if (size <= index) index -= size;
|
|
1497
|
+
else {
|
|
1498
|
+
expr = arg;
|
|
1499
|
+
break;
|
|
1500
|
+
}
|
|
1501
|
+
}
|
|
1502
|
+
}
|
|
1503
|
+
}
|
|
1504
|
+
|
|
1505
|
+
private mkMulHoist(args: number[]): Result {
|
|
1506
|
+
if (args.length <= 1) return undefined;
|
|
1507
|
+
for (let index = 0; index < args.length; index++) {
|
|
1508
|
+
if (!this.isBinary(args[index], OP_BSHL)) continue;
|
|
1509
|
+
const newArgs = [...args];
|
|
1510
|
+
newArgs[index] = this.manager.getArg(args[index], 0);
|
|
1511
|
+
const product = this.app(OP_BMUL, newArgs);
|
|
1512
|
+
return rewrite(this.app(OP_BSHL, [product, this.manager.getArg(args[index], 1)]), 2);
|
|
1513
|
+
}
|
|
1514
|
+
return undefined;
|
|
1515
|
+
}
|
|
1516
|
+
|
|
1517
|
+
private mkBvMul(args: number[]): Result {
|
|
1518
|
+
const manager = this.manager;
|
|
1519
|
+
const result = this.mkMul(args);
|
|
1520
|
+
if (result !== undefined && typeof result !== "number") return result;
|
|
1521
|
+
const hoisted =
|
|
1522
|
+
result === undefined
|
|
1523
|
+
? this.mkMulHoist(args)
|
|
1524
|
+
: this.isMul(result)
|
|
1525
|
+
? this.mkMulHoist(manager.getArgs(result))
|
|
1526
|
+
: undefined;
|
|
1527
|
+
if (hoisted !== undefined) return hoisted;
|
|
1528
|
+
const product =
|
|
1529
|
+
result === undefined
|
|
1530
|
+
? args.length === 2
|
|
1531
|
+
? args
|
|
1532
|
+
: undefined
|
|
1533
|
+
: this.isMul(result) && manager.getNumArgs(result) === 2
|
|
1534
|
+
? manager.getArgs(result)
|
|
1535
|
+
: undefined;
|
|
1536
|
+
if (!this.bvOptions.isMul2concat || product === undefined) return result;
|
|
1537
|
+
const value = this.getNumeral(product[0]);
|
|
1538
|
+
const shift = value === undefined ? -1 : getPowerOfTwoExponent(value);
|
|
1539
|
+
if (shift === -1) return result;
|
|
1540
|
+
const size = this.getSize(product[0]);
|
|
1541
|
+
const kept = this.mkExtractTerm(size - shift - 1, 0, product[1]);
|
|
1542
|
+
return rewrite(this.mkConcatTerm([kept, this.mkZero(shift)]), 2);
|
|
1543
|
+
}
|
|
1544
|
+
|
|
1545
|
+
private mkMkbv(args: number[]) {
|
|
1546
|
+
const manager = this.manager;
|
|
1547
|
+
if (this.bvOptions.isMkbv2num !== true) return undefined;
|
|
1548
|
+
let value = 0n;
|
|
1549
|
+
for (let index = args.length - 1; index >= 0; index--) {
|
|
1550
|
+
if (!manager.isTrue(args[index]) && !manager.isFalse(args[index])) return undefined;
|
|
1551
|
+
value = value * 2n + (manager.isTrue(args[index]) ? 1n : 0n);
|
|
1552
|
+
}
|
|
1553
|
+
return this.mkBv(value, args.length);
|
|
1554
|
+
}
|
|
1555
|
+
|
|
1556
|
+
private mkBit2boolIndex(arg: number, index: number): Result {
|
|
1557
|
+
const manager = this.manager;
|
|
1558
|
+
if (manager.getOp(arg) === OP_MKBV) return manager.getArg(arg, index);
|
|
1559
|
+
const value = this.getNumeral(arg);
|
|
1560
|
+
if (value === undefined || index < 0 || index >= this.getSize(arg)) return undefined;
|
|
1561
|
+
return ((value >> BigInt(index)) & 1n) === 1n ? manager.trueExpr : manager.falseExpr;
|
|
1562
|
+
}
|
|
1563
|
+
|
|
1564
|
+
private mkBit2boolEq(inputLeft: number, inputRight: number): Result {
|
|
1565
|
+
const manager = this.manager;
|
|
1566
|
+
if (this.getSize(inputLeft) !== 1) return undefined;
|
|
1567
|
+
const isSwapped = this.isNumeral(inputLeft);
|
|
1568
|
+
const left = isSwapped ? inputRight : inputLeft;
|
|
1569
|
+
const right = isSwapped ? inputLeft : inputRight;
|
|
1570
|
+
const value = this.getNumeral(right);
|
|
1571
|
+
if (value === undefined) return undefined;
|
|
1572
|
+
if (this.isNumeral(left)) return left === right ? manager.trueExpr : manager.falseExpr;
|
|
1573
|
+
if (this.isIte(left)) {
|
|
1574
|
+
const thenEq = this.boolRewrites.mkEq(manager.getArg(left, 1), right);
|
|
1575
|
+
const elseEq = this.boolRewrites.mkEq(manager.getArg(left, 2), right);
|
|
1576
|
+
return rewrite(this.boolRewrites.mkIte(manager.getArg(left, 0), thenEq, elseEq), 2);
|
|
1577
|
+
}
|
|
1578
|
+
if (manager.getOp(left) === OP_BNOT)
|
|
1579
|
+
return rewrite(manager.mkEq(manager.getArg(left, 0), this.mkBv(1n - value, 1)), 1);
|
|
1580
|
+
const isOne = value === 1n;
|
|
1581
|
+
const op = manager.getOp(left);
|
|
1582
|
+
if (op === OP_BOR || op === OP_BXOR) {
|
|
1583
|
+
const one = isOne ? right : this.mkOne(1);
|
|
1584
|
+
const eqs = manager.mapArgs(left, (arg) => manager.mkEq(arg, one));
|
|
1585
|
+
const junction = op === OP_BOR ? this.mkOrTerm(eqs) : manager.mkApp(OP_XOR, eqs, SORT_BOOL);
|
|
1586
|
+
return isOne ? rewrite(junction, 2) : rewrite(manager.mkNot(junction), 3);
|
|
1587
|
+
}
|
|
1588
|
+
return undefined;
|
|
1589
|
+
}
|
|
1590
|
+
|
|
1591
|
+
private mkEqConcat(left: number, right: number): Rewrite {
|
|
1592
|
+
const manager = this.manager;
|
|
1593
|
+
const leftArgs = this.isConcat(left) ? manager.getArgs(left) : [left];
|
|
1594
|
+
const rightArgs = this.isConcat(right) ? manager.getArgs(right) : [right];
|
|
1595
|
+
const eqs: number[] = [];
|
|
1596
|
+
let leftLow = 0;
|
|
1597
|
+
let rightLow = 0;
|
|
1598
|
+
let leftIndex = leftArgs.length;
|
|
1599
|
+
let rightIndex = rightArgs.length;
|
|
1600
|
+
while (leftIndex > 0 && rightIndex > 0) {
|
|
1601
|
+
const leftArg = leftArgs[leftIndex - 1];
|
|
1602
|
+
const rightArg = rightArgs[rightIndex - 1];
|
|
1603
|
+
const leftSize = this.getSize(leftArg);
|
|
1604
|
+
const rightSize = this.getSize(rightArg);
|
|
1605
|
+
const leftRest = leftSize - leftLow;
|
|
1606
|
+
const rightRest = rightSize - rightLow;
|
|
1607
|
+
if (leftRest === rightRest) {
|
|
1608
|
+
const leftExtract = this.mkExtractTerm(leftSize - 1, leftLow, leftArg);
|
|
1609
|
+
eqs.push(manager.mkEq(leftExtract, this.mkExtractTerm(rightSize - 1, rightLow, rightArg)));
|
|
1610
|
+
leftLow = 0;
|
|
1611
|
+
rightLow = 0;
|
|
1612
|
+
leftIndex--;
|
|
1613
|
+
rightIndex--;
|
|
1614
|
+
} else if (leftRest < rightRest) {
|
|
1615
|
+
const leftExtract = this.mkExtractTerm(leftSize - 1, leftLow, leftArg);
|
|
1616
|
+
eqs.push(
|
|
1617
|
+
manager.mkEq(
|
|
1618
|
+
leftExtract,
|
|
1619
|
+
this.mkExtractTerm(leftRest + rightLow - 1, rightLow, rightArg),
|
|
1620
|
+
),
|
|
1621
|
+
);
|
|
1622
|
+
leftLow = 0;
|
|
1623
|
+
rightLow += leftRest;
|
|
1624
|
+
leftIndex--;
|
|
1625
|
+
} else {
|
|
1626
|
+
const leftExtract = this.mkExtractTerm(rightRest + leftLow - 1, leftLow, leftArg);
|
|
1627
|
+
eqs.push(manager.mkEq(leftExtract, this.mkExtractTerm(rightSize - 1, rightLow, rightArg)));
|
|
1628
|
+
leftLow += rightRest;
|
|
1629
|
+
rightLow = 0;
|
|
1630
|
+
rightIndex--;
|
|
1631
|
+
}
|
|
1632
|
+
}
|
|
1633
|
+
return rewrite(eqs.length === 1 ? eqs[0] : this.mkAndTerm(eqs), 3);
|
|
1634
|
+
}
|
|
1635
|
+
|
|
1636
|
+
private isConcatSplitTarget(expr: number) {
|
|
1637
|
+
const op = this.manager.getOp(expr);
|
|
1638
|
+
return (
|
|
1639
|
+
(this.bvOptions.isSplitConcatEq && this.manager.kinds[expr] !== KIND_VAR) ||
|
|
1640
|
+
op === OP_CONCAT ||
|
|
1641
|
+
this.isNumeral(expr) ||
|
|
1642
|
+
op === OP_BOR
|
|
1643
|
+
);
|
|
1644
|
+
}
|
|
1645
|
+
|
|
1646
|
+
private isConcatTarget(left: number, right: number) {
|
|
1647
|
+
return (
|
|
1648
|
+
(this.isConcat(left) && this.isConcatSplitTarget(right)) ||
|
|
1649
|
+
(this.isConcat(right) && this.isConcatSplitTarget(left))
|
|
1650
|
+
);
|
|
1651
|
+
}
|
|
1652
|
+
|
|
1653
|
+
private isAddMulConst(expr: number) {
|
|
1654
|
+
const manager = this.manager;
|
|
1655
|
+
return (
|
|
1656
|
+
manager.getOp(expr) === OP_BADD &&
|
|
1657
|
+
!manager.someArg(
|
|
1658
|
+
expr,
|
|
1659
|
+
(arg) =>
|
|
1660
|
+
!this.isNumeral(arg) &&
|
|
1661
|
+
!(this.isBinary(arg, OP_BMUL) && this.isNumeral(manager.getArg(arg, 0))),
|
|
1662
|
+
)
|
|
1663
|
+
);
|
|
1664
|
+
}
|
|
1665
|
+
|
|
1666
|
+
private mkMulEq(left: number, right: number): Result {
|
|
1667
|
+
const manager = this.manager;
|
|
1668
|
+
if (this.isBinary(left, OP_BMUL)) {
|
|
1669
|
+
const coefficient = this.getNumeral(manager.getArg(left, 0));
|
|
1670
|
+
const size = this.getSize(left);
|
|
1671
|
+
const inverse = coefficient === undefined ? undefined : getMultInverse(coefficient, size);
|
|
1672
|
+
if (inverse !== undefined) {
|
|
1673
|
+
const term = manager.getArg(left, 1);
|
|
1674
|
+
const rightValue = this.getNumeral(right);
|
|
1675
|
+
if (rightValue !== undefined)
|
|
1676
|
+
return rewrite(manager.mkEq(term, this.mkBv(inverse * rightValue, size)), 1);
|
|
1677
|
+
if (this.isBinary(right, OP_BMUL)) {
|
|
1678
|
+
const rightCoefficient = this.getNumeral(manager.getArg(right, 0));
|
|
1679
|
+
if (rightCoefficient !== undefined) {
|
|
1680
|
+
const rightTerm = manager.getArg(right, 1);
|
|
1681
|
+
if (this.norm(inverse * rightCoefficient, size) === 1n)
|
|
1682
|
+
return rewrite(manager.mkEq(term, rightTerm), 1);
|
|
1683
|
+
const factor = this.mkBv(inverse * rightCoefficient, size);
|
|
1684
|
+
return rewrite(manager.mkEq(term, this.app(OP_BMUL, [factor, rightTerm])), 1);
|
|
1685
|
+
}
|
|
1686
|
+
}
|
|
1687
|
+
if (this.isAddMulConst(right)) {
|
|
1688
|
+
const factor = this.mkBv(inverse, size);
|
|
1689
|
+
return rewrite(manager.mkEq(term, this.app(OP_BMUL, [factor, right])), 2);
|
|
1690
|
+
}
|
|
1691
|
+
}
|
|
1692
|
+
}
|
|
1693
|
+
const leftValue = this.getNumeral(left);
|
|
1694
|
+
if (leftValue !== undefined && this.isAddMulConst(right)) {
|
|
1695
|
+
const size = this.getSize(left);
|
|
1696
|
+
for (let index = 0; index < manager.getNumArgs(right); index++) {
|
|
1697
|
+
const arg = manager.getArg(right, index);
|
|
1698
|
+
if (!this.isBinary(arg, OP_BMUL)) continue;
|
|
1699
|
+
const coefficient = this.getNumeral(manager.getArg(arg, 0));
|
|
1700
|
+
const inverse = coefficient === undefined ? undefined : getMultInverse(coefficient, size);
|
|
1701
|
+
if (inverse === undefined) continue;
|
|
1702
|
+
const value = this.mkBv(inverse * leftValue, size);
|
|
1703
|
+
const product = this.app(OP_BMUL, [this.mkBv(inverse, size), right]);
|
|
1704
|
+
return rewrite(manager.mkEq(value, product), 3);
|
|
1705
|
+
}
|
|
1706
|
+
}
|
|
1707
|
+
return undefined;
|
|
1708
|
+
}
|
|
1709
|
+
|
|
1710
|
+
mkEqCore(inputLeft: number, inputRight: number): Result {
|
|
1711
|
+
const manager = this.manager;
|
|
1712
|
+
if (inputLeft === inputRight) return manager.trueExpr;
|
|
1713
|
+
if (this.isNumeral(inputLeft) && this.isNumeral(inputRight)) return manager.falseExpr;
|
|
1714
|
+
const isSwapped = this.isNumeral(inputLeft);
|
|
1715
|
+
let left = isSwapped ? inputRight : inputLeft;
|
|
1716
|
+
let right = isSwapped ? inputLeft : inputRight;
|
|
1717
|
+
const bit2bool = this.mkBit2boolEq(left, right);
|
|
1718
|
+
if (bit2bool !== undefined) return bit2bool;
|
|
1719
|
+
const mulEq = this.mkMulEq(left, right) ?? this.mkMulEq(right, left);
|
|
1720
|
+
if (mulEq !== undefined) return mulEq;
|
|
1721
|
+
const leftOp = manager.getOp(left);
|
|
1722
|
+
if ((leftOp === OP_BUREM || leftOp === OP_BUREM_I) && manager.getNumArgs(left) === 2) {
|
|
1723
|
+
const rightValue = this.getNumeral(right);
|
|
1724
|
+
const divisor = manager.getArg(left, 1);
|
|
1725
|
+
const divisorValue = this.getNumeral(divisor);
|
|
1726
|
+
if (rightValue !== undefined && divisorValue !== undefined) {
|
|
1727
|
+
if (divisorValue !== 0n && rightValue >= divisorValue) return manager.falseExpr;
|
|
1728
|
+
if (divisorValue + rightValue >= getPowerOfTwo(this.getSize(divisor)))
|
|
1729
|
+
return rewrite(manager.mkEq(manager.getArg(left, 0), right), 2);
|
|
1730
|
+
}
|
|
1731
|
+
}
|
|
1732
|
+
const isPolynomial = (expr: number) => this.isAdd(expr) || this.isMul(expr);
|
|
1733
|
+
if (isPolynomial(left) || isPolynomial(right)) {
|
|
1734
|
+
const cancelled = this.cancelMonomials(left, right, false);
|
|
1735
|
+
if (cancelled !== undefined) {
|
|
1736
|
+
if (this.isNumeral(cancelled.lhs) && this.isNumeral(cancelled.rhs))
|
|
1737
|
+
return cancelled.lhs === cancelled.rhs ? manager.trueExpr : manager.falseExpr;
|
|
1738
|
+
left = cancelled.lhs;
|
|
1739
|
+
right = cancelled.rhs;
|
|
1740
|
+
}
|
|
1741
|
+
const isolated = this.isolateTerm(left, right);
|
|
1742
|
+
if (isolated !== undefined) return rewrite(isolated, 2);
|
|
1743
|
+
if (this.isConcatTarget(left, right)) return this.mkEqConcat(left, right);
|
|
1744
|
+
if (cancelled !== undefined) return manager.mkEq(left, right);
|
|
1745
|
+
}
|
|
1746
|
+
if (this.isConcatTarget(left, right)) return this.mkEqConcat(left, right);
|
|
1747
|
+
if (isSwapped) return manager.mkEq(left, right);
|
|
1748
|
+
return undefined;
|
|
1749
|
+
}
|
|
1750
|
+
|
|
1751
|
+
private isolateTerm(inputLeft: number, inputRight: number) {
|
|
1752
|
+
const manager = this.manager;
|
|
1753
|
+
const isOrdered = this.isNumeral(inputLeft) && this.isAdd(inputRight);
|
|
1754
|
+
const left = isOrdered ? inputLeft : inputRight;
|
|
1755
|
+
const right = isOrdered ? inputRight : inputLeft;
|
|
1756
|
+
if (!this.isNumeral(left) || !this.isAdd(right)) return undefined;
|
|
1757
|
+
const numArgs = manager.getNumArgs(right);
|
|
1758
|
+
const first = manager.getArg(right, 0);
|
|
1759
|
+
const rest =
|
|
1760
|
+
numArgs > 2 ? this.app(OP_BADD, manager.getArgs(right).slice(1)) : manager.getArg(right, 1);
|
|
1761
|
+
const isMinusOneTimes =
|
|
1762
|
+
this.isBinary(first, OP_BMUL) && this.isAllOnes(manager.getArg(first, 0));
|
|
1763
|
+
return isMinusOneTimes
|
|
1764
|
+
? manager.mkEq(rest, this.app(OP_BSUB, [left, first]))
|
|
1765
|
+
: manager.mkEq(first, this.app(OP_BSUB, [left, rest]));
|
|
1766
|
+
}
|
|
1767
|
+
|
|
1768
|
+
mkEqBv2int(inputLeft: number, inputRight: number): Result {
|
|
1769
|
+
const manager = this.manager;
|
|
1770
|
+
const isSwapped = manager.isNumeral(inputLeft);
|
|
1771
|
+
const left = isSwapped ? inputRight : inputLeft;
|
|
1772
|
+
const right = isSwapped ? inputLeft : inputRight;
|
|
1773
|
+
if (manager.isNumeral(right) && manager.getOp(left) === OP_UBV2INT) {
|
|
1774
|
+
const inner = manager.getArg(left, 0);
|
|
1775
|
+
const size = this.getSize(inner);
|
|
1776
|
+
const value = manager.getRationalValue(right);
|
|
1777
|
+
return rewrite(
|
|
1778
|
+
value.isInt() && value.num >= 0n && value.num < getPowerOfTwo(size)
|
|
1779
|
+
? manager.mkEq(this.mkBv(value.num, size), inner)
|
|
1780
|
+
: manager.falseExpr,
|
|
1781
|
+
1,
|
|
1782
|
+
);
|
|
1783
|
+
}
|
|
1784
|
+
if (manager.getOp(left) === OP_UBV2INT && manager.getOp(right) === OP_UBV2INT) {
|
|
1785
|
+
const leftInner = manager.getArg(left, 0);
|
|
1786
|
+
const rightInner = manager.getArg(right, 0);
|
|
1787
|
+
const leftSize = this.getSize(leftInner);
|
|
1788
|
+
const rightSize = this.getSize(rightInner);
|
|
1789
|
+
const extendedLeft =
|
|
1790
|
+
leftSize < rightSize
|
|
1791
|
+
? this.app(OP_ZERO_EXT, [leftInner], [rightSize - leftSize])
|
|
1792
|
+
: leftInner;
|
|
1793
|
+
const extendedRight =
|
|
1794
|
+
leftSize > rightSize
|
|
1795
|
+
? this.app(OP_ZERO_EXT, [rightInner], [leftSize - rightSize])
|
|
1796
|
+
: rightInner;
|
|
1797
|
+
return rewrite(manager.mkEq(extendedLeft, extendedRight), 2);
|
|
1798
|
+
}
|
|
1799
|
+
return undefined;
|
|
1800
|
+
}
|
|
1801
|
+
|
|
1802
|
+
getEqBit(expr: number) {
|
|
1803
|
+
const manager = this.manager;
|
|
1804
|
+
if (manager.getOp(expr) !== OP_EQ) return undefined;
|
|
1805
|
+
const left = manager.getArg(expr, 0);
|
|
1806
|
+
const right = manager.getArg(expr, 1);
|
|
1807
|
+
const getBit = (arg: number) =>
|
|
1808
|
+
this.manager.isBvSort(this.manager.sorts[arg]) && this.getSize(arg) === 1
|
|
1809
|
+
? this.getNumeral(arg)
|
|
1810
|
+
: undefined;
|
|
1811
|
+
const leftBit = getBit(left);
|
|
1812
|
+
if (leftBit !== undefined) return { term: right, bit: leftBit };
|
|
1813
|
+
const rightBit = getBit(right);
|
|
1814
|
+
if (rightBit !== undefined) return { term: left, bit: rightBit };
|
|
1815
|
+
return undefined;
|
|
1816
|
+
}
|
|
1817
|
+
|
|
1818
|
+
mkIteCore(condition: number, thenExpr: number, elseExpr: number): Result {
|
|
1819
|
+
const manager = this.manager;
|
|
1820
|
+
if (thenExpr === elseExpr) return rewrite(elseExpr, 1);
|
|
1821
|
+
if (manager.isNot(condition))
|
|
1822
|
+
return rewrite(this.mkIteTerm(manager.getArg(condition, 0), elseExpr, thenExpr), 1);
|
|
1823
|
+
const thenZero = this.isZeroExtended(thenExpr);
|
|
1824
|
+
const elseZero = thenZero === undefined ? undefined : this.isZeroExtended(elseExpr);
|
|
1825
|
+
if (
|
|
1826
|
+
thenZero !== undefined &&
|
|
1827
|
+
elseZero !== undefined &&
|
|
1828
|
+
this.getSize(thenZero) === this.getSize(elseZero)
|
|
1829
|
+
) {
|
|
1830
|
+
const inner = this.mkIteTerm(condition, thenZero, elseZero);
|
|
1831
|
+
return rewrite(
|
|
1832
|
+
this.app(OP_ZERO_EXT, [inner], [this.getSize(thenExpr) - this.getSize(thenZero)]),
|
|
1833
|
+
2,
|
|
1834
|
+
);
|
|
1835
|
+
}
|
|
1836
|
+
const thenSign = this.isSignExtended(thenExpr);
|
|
1837
|
+
const elseSign = thenSign === undefined ? undefined : this.isSignExtended(elseExpr);
|
|
1838
|
+
if (
|
|
1839
|
+
thenSign !== undefined &&
|
|
1840
|
+
elseSign !== undefined &&
|
|
1841
|
+
this.getSize(thenSign) === this.getSize(elseSign)
|
|
1842
|
+
) {
|
|
1843
|
+
const inner = this.mkIteTerm(condition, thenSign, elseSign);
|
|
1844
|
+
return rewrite(
|
|
1845
|
+
this.app(OP_SIGN_EXT, [inner], [this.getSize(thenExpr) - this.getSize(thenSign)]),
|
|
1846
|
+
2,
|
|
1847
|
+
);
|
|
1848
|
+
}
|
|
1849
|
+
const eqBit = this.getEqBit(condition);
|
|
1850
|
+
const getBit = (arg: number) => (this.getSize(arg) === 1 ? this.getNumeral(arg) : undefined);
|
|
1851
|
+
const thenBit = getBit(thenExpr);
|
|
1852
|
+
const elseBit = getBit(elseExpr);
|
|
1853
|
+
if (eqBit !== undefined && thenBit !== undefined && elseBit !== undefined) {
|
|
1854
|
+
if (eqBit.bit === thenBit && elseBit !== thenBit) return eqBit.term;
|
|
1855
|
+
if (eqBit.bit === elseBit && elseBit !== thenBit)
|
|
1856
|
+
return rewrite(this.mkNotTerm(eqBit.term), 1);
|
|
1857
|
+
}
|
|
1858
|
+
return undefined;
|
|
1859
|
+
}
|
|
1860
|
+
|
|
1861
|
+
mkDistinct(args: number[]): Result {
|
|
1862
|
+
if (args.length <= 1) return this.manager.trueExpr;
|
|
1863
|
+
const size = this.getSize(args[0]);
|
|
1864
|
+
if (size >= 32 || args.length <= 2 ** size) return undefined;
|
|
1865
|
+
return this.manager.falseExpr;
|
|
1866
|
+
}
|
|
1867
|
+
|
|
1868
|
+
private mkBvsmulNoOverflow(args: number[], isOverflow: boolean): Result {
|
|
1869
|
+
const manager = this.manager;
|
|
1870
|
+
const first = this.getNumeral(args[0]);
|
|
1871
|
+
const second = this.getNumeral(args[1]);
|
|
1872
|
+
const size = this.getSize(args[0]);
|
|
1873
|
+
if (first !== undefined && (first === 0n || (size !== 1 && first === 1n)))
|
|
1874
|
+
return manager.trueExpr;
|
|
1875
|
+
if (second !== undefined && (second === 0n || (size !== 1 && second === 1n)))
|
|
1876
|
+
return manager.trueExpr;
|
|
1877
|
+
if (first === undefined || second === undefined) return undefined;
|
|
1878
|
+
const isFirstNegative = this.hasSignBit(first, size);
|
|
1879
|
+
const isSecondNegative = this.hasSignBit(second, size);
|
|
1880
|
+
const firstMagnitude = isFirstNegative ? getPowerOfTwo(size) - first : first;
|
|
1881
|
+
const secondMagnitude = isSecondNegative ? getPowerOfTwo(size) - second : second;
|
|
1882
|
+
const limit = getPowerOfTwo(size - 1);
|
|
1883
|
+
const product = firstMagnitude * secondMagnitude;
|
|
1884
|
+
const isValid = isOverflow
|
|
1885
|
+
? isFirstNegative !== isSecondNegative || product < limit
|
|
1886
|
+
: isFirstNegative === isSecondNegative || product <= limit;
|
|
1887
|
+
return isValid ? manager.trueExpr : manager.falseExpr;
|
|
1888
|
+
}
|
|
1889
|
+
|
|
1890
|
+
private mkBvumulNoOverflow(args: number[]): Result {
|
|
1891
|
+
const manager = this.manager;
|
|
1892
|
+
const first = this.getNumeral(args[0]);
|
|
1893
|
+
const second = this.getNumeral(args[1]);
|
|
1894
|
+
if (first !== undefined && (first === 0n || first === 1n)) return manager.trueExpr;
|
|
1895
|
+
if (second !== undefined && (second === 0n || second === 1n)) return manager.trueExpr;
|
|
1896
|
+
if (first === undefined || second === undefined) return undefined;
|
|
1897
|
+
return first * second < getPowerOfTwo(this.getSize(args[0]))
|
|
1898
|
+
? manager.trueExpr
|
|
1899
|
+
: manager.falseExpr;
|
|
1900
|
+
}
|
|
1901
|
+
}
|