tla-ts 0.0.10-dev.b4a856304 → 0.0.10-dev.d618a2d79
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 +57 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +37 -0
- package/dist/index.d.ts +37 -0
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove.cjs +2683 -427
- package/dist/prove.js +2681 -425
- package/dist/run.cjs +47 -44
- package/dist/run.js +47 -44
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +44 -41
- package/dist/transfer.js +44 -41
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +41 -41
- package/src/bags.ts +2 -5
- package/src/builtins.ts +5 -21
- package/src/check-failure.ts +116 -0
- package/src/check-trace.ts +268 -0
- package/src/check.ts +474 -718
- package/src/cli/options.ts +6 -31
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +8 -7
- package/src/cli/shared.ts +1 -5
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +244 -238
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +3 -5
- package/src/cli/tlc.ts +49 -702
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +5 -10
- package/src/coverage.ts +3 -10
- package/src/dependencies.ts +30 -14
- package/src/dfid.ts +16 -16
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +55 -338
- package/src/errors.ts +33 -5
- package/src/evaluate.ts +31 -106
- package/src/exit-codes.ts +2 -0
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +47 -10
- package/src/java-hash.ts +7 -0
- package/src/java-overrides.ts +4 -9
- package/src/json-reader.ts +1 -2
- package/src/json.ts +8 -18
- package/src/levels.ts +46 -57
- package/src/lexer.ts +76 -85
- package/src/liveness-checker.ts +616 -306
- package/src/liveness.ts +104 -120
- 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 +38 -8
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +28 -41
- package/src/obligations/normalize.ts +26 -14
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +43 -13
- 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 +118 -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 +10 -30
- package/src/parallel.ts +50 -80
- package/src/parser.ts +722 -385
- package/src/pcal/ast.ts +53 -65
- package/src/pcal/parse.ts +144 -191
- package/src/pcal/tokenize.ts +91 -115
- package/src/pcal/translate.ts +83 -98
- package/src/pcal/validate.ts +48 -50
- package/src/pretty-print.ts +7 -7
- 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 +224 -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 +0 -2
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +17 -28
- 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 +6 -17
- 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 +0 -2
- 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/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 +1021 -618
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -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 +613 -6
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +309 -0
- package/src/prover/smt/solver/asserted-formulas.ts +87 -16
- package/src/prover/smt/solver/ast-lt.ts +166 -12
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1427 -41
- package/src/prover/smt/solver/auf-solver.ts +2 -6
- package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +600 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +110 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -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 +278 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +516 -115
- package/src/prover/smt/solver/ctx-simplify.ts +20 -10
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +206 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +7 -8
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +545 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +908 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1205 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1050 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +830 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +335 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +146 -0
- package/src/prover/smt/solver/factor.ts +141 -0
- package/src/prover/smt/solver/fd-solver.ts +265 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +148 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +640 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2249 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +175 -15
- package/src/prover/smt/solver/goal2nlsat.ts +189 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +30 -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 +110 -38
- 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 +345 -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 +18 -3
- 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 +40 -4
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
- 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 +67 -16
- 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 +9 -5
- 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 +122 -64
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-solver.ts +0 -2
- package/src/prover/smt/solver/lp/pdd.ts +2 -2
- 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 +309 -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 +105 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +18 -27
- package/src/prover/smt/solver/model-evaluator.ts +188 -12
- package/src/prover/smt/solver/model-finder.ts +12 -18
- package/src/prover/smt/solver/model-generator.ts +56 -29
- 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 +711 -0
- package/src/prover/smt/solver/mus.ts +51 -0
- package/src/prover/smt/solver/muz/dl-context.ts +404 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1406 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +218 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +125 -12
- package/src/prover/smt/solver/nlsat/atoms.ts +20 -6
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +63 -23
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +3 -9
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +13 -6
- package/src/prover/smt/solver/nlsat/solver.ts +236 -45
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +367 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +0 -2
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +105 -23
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +787 -0
- package/src/prover/smt/solver/opt-nlsat.ts +375 -0
- package/src/prover/smt/solver/opt-pareto.ts +282 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +308 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +284 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +202 -57
- package/src/prover/smt/solver/probes.ts +512 -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 +632 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1098 -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 +37 -17
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1498 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +814 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
- package/src/prover/smt/solver/quantifier-manager.ts +8 -16
- 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 +261 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
- package/src/prover/smt/solver/rewriter.ts +475 -36
- package/src/prover/smt/solver/rlimit.ts +38 -2
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +43 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2127 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +1010 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +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 +728 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1170 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2402 -0
- package/src/prover/smt/solver/seq-skolem.ts +317 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +83 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +496 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3126 -316
- package/src/prover/smt/solver/smtlib-script.ts +1631 -0
- package/src/prover/smt/solver/solve-eqs.ts +929 -0
- package/src/prover/smt/solver/solver.ts +113 -22
- 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 +1986 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1200 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
- package/src/prover/smt/solver/theory-lra-final-check.ts +56 -70
- package/src/prover/smt/solver/theory-lra-internalize.ts +94 -27
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +24 -26
- package/src/prover/smt/solver/theory-lra-state.ts +6 -22
- package/src/prover/smt/solver/theory-lra.ts +188 -1
- package/src/prover/smt/solver/theory-pb.ts +934 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +871 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +50 -19
- 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 +11 -21
- package/src/prover/zenon/isar-case.ts +0 -2
- package/src/prover/zenon/isar.ts +35 -37
- 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 +0 -2
- 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/randomization.ts +1 -4
- package/src/resolve.ts +67 -143
- package/src/runtime.ts +15 -18
- package/src/sany/builtins.ts +1 -3
- package/src/sany/generation.ts +394 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +686 -0
- package/src/sany/generator-expressions.ts +1100 -0
- package/src/sany/generator-proofs.ts +662 -0
- package/src/sany/generator.ts +160 -2683
- package/src/sany/levels.ts +5 -11
- package/src/sany/lexer.ts +57 -60
- package/src/sany/linter.ts +0 -3
- package/src/sany/nodes.ts +6 -13
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +35 -38
- package/src/sany/xml.ts +23 -55
- package/src/search.ts +206 -44
- package/src/simulate.ts +202 -184
- package/src/spec-description.ts +56 -82
- package/src/standard-definitions.ts +4 -3
- package/src/standard-modules.ts +17 -44
- package/src/state-graph.ts +3 -17
- package/src/subexpressions.ts +38 -47
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +20 -43
- package/src/symmetry.ts +6 -21
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +96 -30
- package/src/tlc/jar-data.ts +0 -1
- package/src/tlc/messages.ts +22 -36
- package/src/tlc/order.ts +22 -47
- package/src/tlc/random.ts +22 -34
- package/src/tlc/replay.ts +21 -48
- package/src/tlc/summary.ts +64 -58
- package/src/tlc/tlc-operators.ts +6 -17
- package/src/tlc/tlcext-operators.ts +54 -26
- package/src/tlc/trace-spec.ts +26 -51
- package/src/tlc/value-stream.ts +9 -13
- package/src/tlc/version.ts +0 -1
- package/src/typed-tier.ts +6535 -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/values.ts +136 -338
- 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,1373 @@
|
|
|
1
|
+
import {
|
|
2
|
+
OP_ADD,
|
|
3
|
+
OP_EQ,
|
|
4
|
+
OP_GE,
|
|
5
|
+
OP_ITE,
|
|
6
|
+
OP_LE,
|
|
7
|
+
OP_SEQ_AT,
|
|
8
|
+
OP_SEQ_CONTAINS,
|
|
9
|
+
OP_SEQ_EXTRACT,
|
|
10
|
+
OP_SEQ_FOLDL,
|
|
11
|
+
OP_SEQ_FOLDLI,
|
|
12
|
+
OP_SEQ_INDEX,
|
|
13
|
+
OP_SEQ_LAST_INDEX,
|
|
14
|
+
OP_SEQ_MAP,
|
|
15
|
+
OP_SEQ_MAPI,
|
|
16
|
+
OP_SEQ_NTH_I,
|
|
17
|
+
OP_SEQ_POWER,
|
|
18
|
+
OP_SEQ_PREFIX,
|
|
19
|
+
OP_SEQ_SUFFIX,
|
|
20
|
+
OP_SEQ_UNIT,
|
|
21
|
+
SORT_BOOL,
|
|
22
|
+
} from "./ast";
|
|
23
|
+
import type { Enode } from "./enode";
|
|
24
|
+
import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
25
|
+
import { FALSE_LITERAL, type Literal, negate } from "./literal";
|
|
26
|
+
import { type Dependency, mkJoin } from "./lp/dependency";
|
|
27
|
+
import { Rational } from "./rational";
|
|
28
|
+
import { getMinLengthOf } from "./seq-axioms";
|
|
29
|
+
import { getConcat, mkSeqApp } from "./seq-decl-plugin";
|
|
30
|
+
import type { EqPair } from "./seq-rewriter";
|
|
31
|
+
import { type DecomposedEq, type DepEq, type Ne, TheorySeqState } from "./theory-seq-state";
|
|
32
|
+
|
|
33
|
+
export interface DepState {
|
|
34
|
+
dep: Dependency;
|
|
35
|
+
isChanged: boolean;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
interface Cell {
|
|
39
|
+
parent: Cell | undefined;
|
|
40
|
+
expr: number;
|
|
41
|
+
dep: Dependency;
|
|
42
|
+
last: number;
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
const isSameList = (first: readonly number[], second: readonly number[]) =>
|
|
46
|
+
first.length === second.length && first.every((expr, index) => expr === second[index]);
|
|
47
|
+
|
|
48
|
+
export abstract class TheorySeqSolve extends TheorySeqState {
|
|
49
|
+
protected canonize(expr: number, state: DepState) {
|
|
50
|
+
const expanded = this.expand(expr, state);
|
|
51
|
+
return expanded === undefined ? undefined : this.rewrite(expanded);
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
private canonizeInto(input: number, result: number[], state: DepState): boolean {
|
|
55
|
+
const manager = this.manager;
|
|
56
|
+
let expr = input;
|
|
57
|
+
for (;;) {
|
|
58
|
+
if (this.isConcat(expr)) {
|
|
59
|
+
if (!this.canonizeInto(manager.getArg(expr, 0), result, state)) return false;
|
|
60
|
+
expr = manager.getArg(expr, 1);
|
|
61
|
+
state.isChanged = true;
|
|
62
|
+
continue;
|
|
63
|
+
}
|
|
64
|
+
if (this.isEmpty(expr)) {
|
|
65
|
+
state.isChanged = true;
|
|
66
|
+
return true;
|
|
67
|
+
}
|
|
68
|
+
const expanded = this.expand(expr, state);
|
|
69
|
+
if (expanded === undefined) return false;
|
|
70
|
+
if (expanded !== expr) state.isChanged = true;
|
|
71
|
+
getConcat(manager, expanded, result);
|
|
72
|
+
return true;
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
protected canonizeList(exprs: readonly number[], result: number[], state: DepState) {
|
|
77
|
+
return exprs.every((expr) => this.canonizeInto(expr, result, state));
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
private expand(input: number, state: DepState) {
|
|
81
|
+
const todo = this.expandTodo;
|
|
82
|
+
const size = todo.length;
|
|
83
|
+
todo.push(input);
|
|
84
|
+
let result: number | undefined;
|
|
85
|
+
while (todo.length !== size) {
|
|
86
|
+
const expanded = this.expand1(todo[todo.length - 1], state);
|
|
87
|
+
if (expanded === false) return undefined;
|
|
88
|
+
result = expanded;
|
|
89
|
+
if (result !== undefined) todo.pop();
|
|
90
|
+
}
|
|
91
|
+
return result;
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
private tryExpand(expr: number, state: DepState) {
|
|
95
|
+
const cached = this.rep.findCache(expr);
|
|
96
|
+
if (cached === undefined) {
|
|
97
|
+
this.expandTodo.push(expr);
|
|
98
|
+
return undefined;
|
|
99
|
+
}
|
|
100
|
+
if (expr !== cached.expr) state.dep = mkJoin(state.dep, cached.dep);
|
|
101
|
+
return cached.expr;
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
private expand1(original: number, outer: DepState): number | undefined | false {
|
|
105
|
+
const manager = this.manager;
|
|
106
|
+
const cached = this.tryExpand(original, outer);
|
|
107
|
+
if (cached !== undefined) return cached;
|
|
108
|
+
const found = this.rep.findWithDep(original);
|
|
109
|
+
const expr = found.expr;
|
|
110
|
+
const state: DepState = { dep: found.dep, isChanged: false };
|
|
111
|
+
const op = manager.getOp(expr);
|
|
112
|
+
const numArgs = manager.getNumArgs(expr);
|
|
113
|
+
const expandArgs = (indexes: number[]) => {
|
|
114
|
+
const args = manager.getArgs(expr).slice();
|
|
115
|
+
let isComplete = true;
|
|
116
|
+
for (const index of indexes) {
|
|
117
|
+
const expanded = this.tryExpand(args[index], state);
|
|
118
|
+
if (expanded === undefined) isComplete = false;
|
|
119
|
+
else args[index] = expanded;
|
|
120
|
+
}
|
|
121
|
+
return isComplete ? args : undefined;
|
|
122
|
+
};
|
|
123
|
+
const rebuild = (indexes: number[], isRewriting = false) => {
|
|
124
|
+
const args = expandArgs(indexes);
|
|
125
|
+
if (args === undefined) return undefined;
|
|
126
|
+
const rebuilt = manager.mkApp(manager.decls[expr], args, manager.sorts[expr]);
|
|
127
|
+
return isRewriting ? this.context.rewriter.rewrite(rebuilt) : rebuilt;
|
|
128
|
+
};
|
|
129
|
+
let result: number | undefined;
|
|
130
|
+
if (this.isConcat(expr)) {
|
|
131
|
+
const args = expandArgs([0, 1]);
|
|
132
|
+
if (args === undefined) return undefined;
|
|
133
|
+
result = this.mkConcat2(args[0], args[1]);
|
|
134
|
+
} else if (this.isEmpty(expr) || this.isString(expr)) result = expr;
|
|
135
|
+
else if (op === OP_SEQ_PREFIX || op === OP_SEQ_SUFFIX || op === OP_SEQ_CONTAINS) {
|
|
136
|
+
result = rebuild([0, 1]);
|
|
137
|
+
if (result === undefined) return undefined;
|
|
138
|
+
} else if (op === OP_SEQ_UNIT) {
|
|
139
|
+
result = rebuild([0]);
|
|
140
|
+
if (result === undefined) return undefined;
|
|
141
|
+
} else if (op === OP_SEQ_INDEX && (numArgs === 2 || numArgs === 3)) {
|
|
142
|
+
const args = expandArgs([0, 1]);
|
|
143
|
+
if (args === undefined) return undefined;
|
|
144
|
+
result = mkSeqApp(manager, OP_SEQ_INDEX, [
|
|
145
|
+
args[0],
|
|
146
|
+
args[1],
|
|
147
|
+
numArgs === 2 ? this.mkInt(0) : args[2],
|
|
148
|
+
]);
|
|
149
|
+
} else if (op === OP_SEQ_POWER) {
|
|
150
|
+
result = rebuild([0], true);
|
|
151
|
+
if (result === undefined) return undefined;
|
|
152
|
+
} else if (op === OP_SEQ_MAP) {
|
|
153
|
+
result = rebuild([1], true);
|
|
154
|
+
if (result === undefined) return undefined;
|
|
155
|
+
} else if (op === OP_SEQ_MAPI || op === OP_SEQ_FOLDL) {
|
|
156
|
+
result = rebuild([2], true);
|
|
157
|
+
if (result === undefined) return undefined;
|
|
158
|
+
} else if (op === OP_SEQ_FOLDLI) {
|
|
159
|
+
result = rebuild([3], true);
|
|
160
|
+
if (result === undefined) return undefined;
|
|
161
|
+
} else if (op === OP_SEQ_LAST_INDEX) {
|
|
162
|
+
result = rebuild([0, 1]);
|
|
163
|
+
if (result === undefined) return undefined;
|
|
164
|
+
} else if (op === OP_ITE) {
|
|
165
|
+
const literal = this.mkLiteralOf(manager.getArg(expr, 0));
|
|
166
|
+
const value = this.context.getAssignment(literal);
|
|
167
|
+
if (value === L_UNDEF) {
|
|
168
|
+
this.context.markLiteralAsRelevant(literal);
|
|
169
|
+
this.isNewPropagation = true;
|
|
170
|
+
return false;
|
|
171
|
+
}
|
|
172
|
+
state.dep = this.mkJoinLiteral(state.dep, value === L_TRUE ? literal : negate(literal));
|
|
173
|
+
result = this.tryExpand(manager.getArg(expr, value === L_TRUE ? 1 : 2), state);
|
|
174
|
+
if (result === undefined) return undefined;
|
|
175
|
+
} else result = expr;
|
|
176
|
+
const dep = result === original ? null : state.dep;
|
|
177
|
+
this.rep.addCache(this.keep(original), this.keep(result), dep);
|
|
178
|
+
outer.dep = mkJoin(outer.dep, dep);
|
|
179
|
+
return result;
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
protected solveEqs(start: number) {
|
|
183
|
+
let isChanged = false;
|
|
184
|
+
for (let index = start; !this.context.isInconsistent() && index < this.eqs.size; index++) {
|
|
185
|
+
if (this.solveEq(index)) {
|
|
186
|
+
this.eqs.eraseAndSwap(index--);
|
|
187
|
+
isChanged = true;
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
return isChanged || this.isNewPropagation || this.context.isInconsistent();
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
private solveEq(index: number) {
|
|
194
|
+
const context = this.context;
|
|
195
|
+
const eq = this.eqs.items[index];
|
|
196
|
+
const ls: number[] = [];
|
|
197
|
+
const rs: number[] = [];
|
|
198
|
+
const state: DepState = { dep: null, isChanged: false };
|
|
199
|
+
if (!this.canonizeList(eq.ls, ls, state)) return false;
|
|
200
|
+
if (!this.canonizeList(eq.rs, rs, state)) return false;
|
|
201
|
+
const deps = mkJoin(state.dep, eq.dep);
|
|
202
|
+
const pair = { left: ls, right: rs };
|
|
203
|
+
if (!context.isInconsistent() && this.simplifyEq(pair, deps)) return true;
|
|
204
|
+
if (!context.isInconsistent() && this.liftIte(pair.left, pair.right, deps)) return true;
|
|
205
|
+
this.eqDeps = deps;
|
|
206
|
+
if (!context.isInconsistent() && this.eqSolver.reduce(pair.left, pair.right)) return true;
|
|
207
|
+
if (!context.isInconsistent() && this.solveNthEq(pair.left, pair.right, deps)) return true;
|
|
208
|
+
if (!context.isInconsistent() && this.solveNthEq(pair.right, pair.left, deps)) return true;
|
|
209
|
+
if (!context.isInconsistent() && state.isChanged)
|
|
210
|
+
this.eqs.set(index, this.mkDepEq(this.eqId++, pair.left, pair.right, deps));
|
|
211
|
+
return false;
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
private simplifyEq(pair: { left: number[]; right: number[] }, deps: Dependency) {
|
|
215
|
+
const context = this.context;
|
|
216
|
+
const newEqs: EqPair[] = [];
|
|
217
|
+
const isChanged = this.seqRewriter.reduceEqOf(pair, newEqs);
|
|
218
|
+
if (isChanged === undefined) {
|
|
219
|
+
this.setConflict(deps);
|
|
220
|
+
return true;
|
|
221
|
+
}
|
|
222
|
+
if (!isChanged) return false;
|
|
223
|
+
this.seqRewriter.addSeqs(pair.left, pair.right, newEqs);
|
|
224
|
+
for (const newEq of newEqs) {
|
|
225
|
+
if (context.isInconsistent()) break;
|
|
226
|
+
this.eqDeps = deps;
|
|
227
|
+
if (this.eqSolver.reduce([newEq.left], [newEq.right])) continue;
|
|
228
|
+
if (this.isSeq(newEq.left) || this.isRe(newEq.left))
|
|
229
|
+
this.eqs.push(this.mkEqDep(newEq.left, newEq.right, deps));
|
|
230
|
+
else
|
|
231
|
+
this.propagateEqNodes(
|
|
232
|
+
deps,
|
|
233
|
+
this.ensureEnodeOf(newEq.left),
|
|
234
|
+
this.ensureEnodeOf(newEq.right),
|
|
235
|
+
);
|
|
236
|
+
}
|
|
237
|
+
return true;
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
private liftIte(ls: readonly number[], rs: readonly number[], deps: Dependency) {
|
|
241
|
+
if (ls.length !== 1 || rs.length !== 1) return false;
|
|
242
|
+
const manager = this.manager;
|
|
243
|
+
const isRightIte = this.isOp(rs[0], OP_ITE);
|
|
244
|
+
const left = isRightIte ? rs[0] : ls[0];
|
|
245
|
+
const right = isRightIte ? ls[0] : rs[0];
|
|
246
|
+
if (!this.isOp(left, OP_ITE)) return false;
|
|
247
|
+
const condition = manager.getArg(left, 0);
|
|
248
|
+
const value = this.context.findAssignment(condition);
|
|
249
|
+
if (value === L_UNDEF) return false;
|
|
250
|
+
const literal = this.context.getLiteral(condition);
|
|
251
|
+
const dep = this.mkJoinLiteral(deps, value === L_TRUE ? literal : negate(literal));
|
|
252
|
+
this.eqs.push(this.mkEqDep(manager.getArg(left, value === L_TRUE ? 1 : 2), right, dep));
|
|
253
|
+
return true;
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
private solveNthEq(ls: readonly number[], rs: readonly number[], deps: Dependency) {
|
|
257
|
+
const manager = this.manager;
|
|
258
|
+
if (ls.length !== 1 || !this.isOp(ls[0], OP_SEQ_NTH_I)) return false;
|
|
259
|
+
const seq = manager.getArg(ls[0], 0);
|
|
260
|
+
const index = manager.getArg(ls[0], 1);
|
|
261
|
+
const rhs = this.mkConcat(rs, manager.sorts[ls[0]]);
|
|
262
|
+
if (rs.every((expr) => this.isUnit(expr) || this.isString(expr)))
|
|
263
|
+
return this.addSolution(ls[0], rhs, deps);
|
|
264
|
+
const isIndexZero = manager.getNumeral(index) === 0n;
|
|
265
|
+
const nextIndex = this.rewrite(this.mkArith(OP_ADD, [index, this.mkInt(1)]));
|
|
266
|
+
const key = `${rhs},${ls[0]}`;
|
|
267
|
+
if (this.nthEq2Cache.has(key)) return false;
|
|
268
|
+
this.keep(rhs);
|
|
269
|
+
this.nthEq2Cache.add(key);
|
|
270
|
+
this.trailStack.push(() => {
|
|
271
|
+
this.nthEq2Cache.delete(key);
|
|
272
|
+
});
|
|
273
|
+
const rs1: number[] = [];
|
|
274
|
+
if (!isIndexZero) rs1.push(this.sk.mkPre(seq, index));
|
|
275
|
+
rs1.push(mkSeqApp(manager, OP_SEQ_UNIT, [rhs]));
|
|
276
|
+
rs1.push(this.sk.mkPost(seq, nextIndex));
|
|
277
|
+
this.eqs.push(this.mkDepEq(this.eqId++, [seq], rs1, deps));
|
|
278
|
+
return true;
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
private getLengthOf(expr: number, literals: Literal[]) {
|
|
282
|
+
const manager = this.manager;
|
|
283
|
+
const context = this.context;
|
|
284
|
+
const op = manager.getOp(expr);
|
|
285
|
+
const isTrue = (literal: Literal) => context.getAssignment(literal) === L_TRUE;
|
|
286
|
+
const isZero = (index: number) => manager.getNumeral(index) === 0n;
|
|
287
|
+
if (op === OP_SEQ_EXTRACT) {
|
|
288
|
+
const [seq, index, length] = manager.getArgs(expr);
|
|
289
|
+
const seqLength = this.mkLen(seq);
|
|
290
|
+
const rest = this.mkSub(this.mkSub(seqLength, index), length);
|
|
291
|
+
const antecedents = [
|
|
292
|
+
isZero(index) ? undefined : this.mkGeLiteral(index, 0),
|
|
293
|
+
negate(this.mkGeLiteral(this.mkSub(index, seqLength), 0)),
|
|
294
|
+
this.mkGeLiteral(rest, 0),
|
|
295
|
+
this.mkGeLiteral(length, 0),
|
|
296
|
+
];
|
|
297
|
+
if (!antecedents.every((literal) => literal === undefined || isTrue(literal)))
|
|
298
|
+
return undefined;
|
|
299
|
+
for (const literal of antecedents) if (literal !== undefined) literals.push(literal);
|
|
300
|
+
return length;
|
|
301
|
+
}
|
|
302
|
+
if (op === OP_SEQ_AT || this.sk.isPre(expr)) {
|
|
303
|
+
const seq = manager.getArg(expr, 0);
|
|
304
|
+
const index = manager.getArg(expr, 1);
|
|
305
|
+
const antecedents = [
|
|
306
|
+
isZero(index) ? undefined : this.mkGeLiteral(index, 0),
|
|
307
|
+
negate(this.mkGeLiteral(this.mkSub(index, this.mkLen(seq)), 0)),
|
|
308
|
+
];
|
|
309
|
+
if (!antecedents.every((literal) => literal === undefined || isTrue(literal)))
|
|
310
|
+
return undefined;
|
|
311
|
+
for (const literal of antecedents) if (literal !== undefined) literals.push(literal);
|
|
312
|
+
return op === OP_SEQ_AT ? this.mkInt(1) : index;
|
|
313
|
+
}
|
|
314
|
+
if (this.sk.isPost(expr)) {
|
|
315
|
+
const seq = manager.getArg(expr, 0);
|
|
316
|
+
const index = manager.getArg(expr, 1);
|
|
317
|
+
const isIndexNonNegative = this.mkGeLiteral(index, 0);
|
|
318
|
+
const isWithin = this.mkGeLiteral(this.mkSub(this.mkLen(seq), index), 0);
|
|
319
|
+
if (!isTrue(isIndexNonNegative) || !isTrue(isWithin)) return undefined;
|
|
320
|
+
literals.push(isIndexNonNegative, isWithin);
|
|
321
|
+
return this.mkSub(this.mkLen(seq), index);
|
|
322
|
+
}
|
|
323
|
+
if (this.sk.isTail(expr)) {
|
|
324
|
+
const seq = manager.getArg(expr, 0);
|
|
325
|
+
const index = manager.getArg(expr, 1);
|
|
326
|
+
const seqLength = this.mkLen(seq);
|
|
327
|
+
const isLonger = this.mkGeLiteral(this.mkSub(seqLength, index), 1);
|
|
328
|
+
const value = context.getAssignment(isLonger);
|
|
329
|
+
if (value === L_TRUE) {
|
|
330
|
+
literals.push(isLonger);
|
|
331
|
+
return this.mkSub(this.mkSub(seqLength, index), this.mkInt(1));
|
|
332
|
+
}
|
|
333
|
+
if (value === L_FALSE) {
|
|
334
|
+
literals.push(negate(isLonger));
|
|
335
|
+
return this.mkInt(0);
|
|
336
|
+
}
|
|
337
|
+
return undefined;
|
|
338
|
+
}
|
|
339
|
+
if (op === OP_SEQ_UNIT) return this.mkInt(1);
|
|
340
|
+
return undefined;
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
private reduceLength(left: number, right: number) {
|
|
344
|
+
const literals: Literal[] = [];
|
|
345
|
+
const leftLength = this.getLengthOf(left, literals);
|
|
346
|
+
if (leftLength === undefined) return undefined;
|
|
347
|
+
const rightLength = this.getLengthOf(right, literals);
|
|
348
|
+
return rightLength !== undefined && leftLength === rightLength ? literals : undefined;
|
|
349
|
+
}
|
|
350
|
+
|
|
351
|
+
protected reduceLengthEqOf(ls: readonly number[], rs: readonly number[], inputDeps: Dependency) {
|
|
352
|
+
if (ls.length === 0 || rs.length === 0) return false;
|
|
353
|
+
if (ls.length <= 1 && rs.length <= 1) return false;
|
|
354
|
+
const front = this.reduceLength(ls[0], rs[0]);
|
|
355
|
+
if (front !== undefined) {
|
|
356
|
+
const deps = this.mkJoinLiterals(inputDeps, front);
|
|
357
|
+
this.eqs.push(this.mkDepEq(this.eqId++, ls.slice(1), rs.slice(1), deps));
|
|
358
|
+
this.propagateEq(deps, front, ls[0], rs[0], true);
|
|
359
|
+
return true;
|
|
360
|
+
}
|
|
361
|
+
const back = this.reduceLength(ls[ls.length - 1], rs[rs.length - 1]);
|
|
362
|
+
if (back !== undefined) {
|
|
363
|
+
const deps = this.mkJoinLiterals(inputDeps, back);
|
|
364
|
+
this.eqs.push(this.mkDepEq(this.eqId++, ls.slice(0, -1), rs.slice(0, -1), deps));
|
|
365
|
+
this.propagateEq(deps, back, ls[ls.length - 1], rs[rs.length - 1], true);
|
|
366
|
+
return true;
|
|
367
|
+
}
|
|
368
|
+
const getLength = (expr: number) => this.getLengthValue(expr);
|
|
369
|
+
const sumFront = (first: number, others: readonly number[], isStrict: boolean) => {
|
|
370
|
+
const firstLength = getLength(first);
|
|
371
|
+
if (firstLength === undefined) return undefined;
|
|
372
|
+
let total = getLength(others[0]);
|
|
373
|
+
if (total === undefined) return undefined;
|
|
374
|
+
if (isStrict ? firstLength.compare(total) <= 0 : firstLength.compare(total) < 0)
|
|
375
|
+
return undefined;
|
|
376
|
+
let index = 1;
|
|
377
|
+
for (; index < others.length && firstLength.compare(total) > 0; index++) {
|
|
378
|
+
const length = getLength(others[index]);
|
|
379
|
+
if (length === undefined) break;
|
|
380
|
+
total = total.add(length);
|
|
381
|
+
}
|
|
382
|
+
return firstLength.equals(total) ? index : undefined;
|
|
383
|
+
};
|
|
384
|
+
if (ls.length > 1) {
|
|
385
|
+
const index = sumFront(ls[0], rs, false);
|
|
386
|
+
if (
|
|
387
|
+
index !== undefined &&
|
|
388
|
+
index < rs.length &&
|
|
389
|
+
this.reduceLengthAt(1, index, true, ls, rs, inputDeps)
|
|
390
|
+
)
|
|
391
|
+
return true;
|
|
392
|
+
}
|
|
393
|
+
if (rs.length > 1) {
|
|
394
|
+
const index = sumFront(rs[0], ls, true);
|
|
395
|
+
if (
|
|
396
|
+
index !== undefined &&
|
|
397
|
+
index < ls.length &&
|
|
398
|
+
this.reduceLengthAt(index, 1, true, ls, rs, inputDeps)
|
|
399
|
+
)
|
|
400
|
+
return true;
|
|
401
|
+
}
|
|
402
|
+
const sumBack = (first: number, others: readonly number[], isStrict: boolean) => {
|
|
403
|
+
const firstLength = getLength(first);
|
|
404
|
+
if (firstLength === undefined) return undefined;
|
|
405
|
+
let total = getLength(others[others.length - 1]);
|
|
406
|
+
if (total === undefined) return undefined;
|
|
407
|
+
if (isStrict ? firstLength.compare(total) <= 0 : firstLength.compare(total) < 0)
|
|
408
|
+
return undefined;
|
|
409
|
+
let index = others.length - 1;
|
|
410
|
+
for (; index > 0 && firstLength.compare(total) > 0; index--) {
|
|
411
|
+
const length = getLength(others[index - 1]);
|
|
412
|
+
if (length === undefined) break;
|
|
413
|
+
total = total.add(length);
|
|
414
|
+
}
|
|
415
|
+
return firstLength.equals(total) && index > 0 ? index : undefined;
|
|
416
|
+
};
|
|
417
|
+
if (ls.length > 1) {
|
|
418
|
+
const index = sumBack(ls[ls.length - 1], rs, false);
|
|
419
|
+
if (
|
|
420
|
+
index !== undefined &&
|
|
421
|
+
index < rs.length &&
|
|
422
|
+
this.reduceLengthAt(ls.length - 1, rs.length - index, false, ls, rs, inputDeps)
|
|
423
|
+
)
|
|
424
|
+
return true;
|
|
425
|
+
}
|
|
426
|
+
if (rs.length > 1) {
|
|
427
|
+
const index = sumBack(rs[rs.length - 1], ls, true);
|
|
428
|
+
if (
|
|
429
|
+
index !== undefined &&
|
|
430
|
+
index < ls.length &&
|
|
431
|
+
this.reduceLengthAt(ls.length - index, rs.length - 1, false, ls, rs, inputDeps)
|
|
432
|
+
)
|
|
433
|
+
return true;
|
|
434
|
+
}
|
|
435
|
+
return false;
|
|
436
|
+
}
|
|
437
|
+
|
|
438
|
+
private reduceLengthAt(
|
|
439
|
+
leftIndex: number,
|
|
440
|
+
rightIndex: number,
|
|
441
|
+
isFront: boolean,
|
|
442
|
+
ls: readonly number[],
|
|
443
|
+
rs: readonly number[],
|
|
444
|
+
inputDeps: Dependency,
|
|
445
|
+
) {
|
|
446
|
+
const context = this.context;
|
|
447
|
+
const ls1 = isFront ? ls.slice(0, leftIndex) : ls.slice(leftIndex);
|
|
448
|
+
const ls2 = isFront ? ls.slice(leftIndex) : ls.slice(0, leftIndex);
|
|
449
|
+
const rs1 = isFront ? rs.slice(0, rightIndex) : rs.slice(rightIndex);
|
|
450
|
+
const rs2 = isFront ? rs.slice(rightIndex) : rs.slice(0, rightIndex);
|
|
451
|
+
const sort = this.manager.sorts[ls[0]];
|
|
452
|
+
const left = this.mkConcat(ls1, sort);
|
|
453
|
+
const right = this.mkConcat(rs1, sort);
|
|
454
|
+
const literal = this.mkEqLiteral(this.mkLen(left), this.mkLen(right), false);
|
|
455
|
+
context.markLiteralAsRelevant(literal);
|
|
456
|
+
if (context.getAssignment(literal) !== L_TRUE) return false;
|
|
457
|
+
for (const eq of this.eqs.items)
|
|
458
|
+
if (isSameList(eq.ls, ls2) && isSameList(eq.rs, rs2)) return false;
|
|
459
|
+
const deps = this.mkJoinLiteral(inputDeps, literal);
|
|
460
|
+
this.eqs.push(this.mkDepEq(++this.eqId, ls2, rs2, deps));
|
|
461
|
+
this.propagateEq(deps, [], left, right, true);
|
|
462
|
+
return true;
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
protected solveNqs(start: number) {
|
|
466
|
+
for (let index = start; !this.context.isInconsistent() && index < this.nqs.size; index++)
|
|
467
|
+
if (this.solveNe(index)) this.nqs.eraseAndSwap(index--);
|
|
468
|
+
return this.isNewPropagation || this.context.isInconsistent();
|
|
469
|
+
}
|
|
470
|
+
|
|
471
|
+
private solveNe(index: number) {
|
|
472
|
+
const ne = this.nqs.items[index];
|
|
473
|
+
let numUndef = 0;
|
|
474
|
+
for (const literal of ne.literals) {
|
|
475
|
+
const value = this.context.getAssignment(literal);
|
|
476
|
+
if (value === L_FALSE) return true;
|
|
477
|
+
if (value === L_UNDEF) numUndef++;
|
|
478
|
+
}
|
|
479
|
+
return (
|
|
480
|
+
(numUndef <= 1 && this.propagateNe2Lit(index)) ||
|
|
481
|
+
(numUndef === 0 && this.propagateNe2Eq(index)) ||
|
|
482
|
+
this.reduceNe(index)
|
|
483
|
+
);
|
|
484
|
+
}
|
|
485
|
+
|
|
486
|
+
private propagateNe2Lit(index: number) {
|
|
487
|
+
const context = this.context;
|
|
488
|
+
const ne = this.nqs.items[index];
|
|
489
|
+
if (ne.eqs.length > 0) return false;
|
|
490
|
+
const literals: Literal[] = [];
|
|
491
|
+
let undefLiteral: Literal | undefined;
|
|
492
|
+
for (const literal of ne.literals) {
|
|
493
|
+
const value = context.getAssignment(literal);
|
|
494
|
+
if (value === L_TRUE) literals.push(literal);
|
|
495
|
+
else if (value === L_FALSE) return true;
|
|
496
|
+
else {
|
|
497
|
+
if (undefLiteral !== undefined) return false;
|
|
498
|
+
undefLiteral = literal;
|
|
499
|
+
}
|
|
500
|
+
}
|
|
501
|
+
if (undefLiteral !== undefined) {
|
|
502
|
+
this.propagateLit(ne.dep, literals, negate(undefLiteral));
|
|
503
|
+
return true;
|
|
504
|
+
}
|
|
505
|
+
const explanation = this.explainEq(ne.left, ne.right);
|
|
506
|
+
if (explanation !== undefined) {
|
|
507
|
+
const diseq = this.mkEqLiteral(ne.left, ne.right, false);
|
|
508
|
+
if (context.getAssignment(diseq) === L_FALSE) {
|
|
509
|
+
this.setConflict(explanation, [negate(diseq)]);
|
|
510
|
+
return true;
|
|
511
|
+
}
|
|
512
|
+
}
|
|
513
|
+
this.setConflict(ne.dep, literals);
|
|
514
|
+
return true;
|
|
515
|
+
}
|
|
516
|
+
|
|
517
|
+
private propagateNe2Eq(index: number) {
|
|
518
|
+
const ne = this.nqs.items[index];
|
|
519
|
+
if (ne.eqs.length !== 1) return false;
|
|
520
|
+
const eq = ne.eqs[0];
|
|
521
|
+
if (eq.ls.length === 0) return this.propagateNe2EqOf(ne, eq.rs);
|
|
522
|
+
if (eq.rs.length === 0) return this.propagateNe2EqOf(ne, eq.ls);
|
|
523
|
+
return false;
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
private propagateNe2EqOf(ne: Ne, exprs: readonly number[]) {
|
|
527
|
+
if (exprs.length === 0) return false;
|
|
528
|
+
for (const expr of exprs) {
|
|
529
|
+
const lower = this.lowerBound(this.mkLen(expr));
|
|
530
|
+
if (lower !== undefined && lower.isPositive()) return true;
|
|
531
|
+
}
|
|
532
|
+
const expr = this.mkConcat(exprs);
|
|
533
|
+
const decomposition = this.decompose(expr);
|
|
534
|
+
this.propagateEq(
|
|
535
|
+
ne.dep,
|
|
536
|
+
ne.literals,
|
|
537
|
+
expr,
|
|
538
|
+
this.mkConcat2(decomposition.head, decomposition.tail),
|
|
539
|
+
true,
|
|
540
|
+
);
|
|
541
|
+
return true;
|
|
542
|
+
}
|
|
543
|
+
|
|
544
|
+
private reduceNe(index: number) {
|
|
545
|
+
const context = this.context;
|
|
546
|
+
const ne = this.nqs.items[index];
|
|
547
|
+
let isUpdated = false;
|
|
548
|
+
let newDeps = ne.dep;
|
|
549
|
+
const newEqs: DecomposedEq[] = [];
|
|
550
|
+
const newLiterals = [...ne.literals];
|
|
551
|
+
for (let eqIndex = 0; eqIndex < ne.eqs.length; eqIndex++) {
|
|
552
|
+
const eq = ne.eqs[eqIndex];
|
|
553
|
+
const pair = { left: [] as number[], right: [] as number[] };
|
|
554
|
+
const state: DepState = { dep: null, isChanged: false };
|
|
555
|
+
if (!this.canonizeList(eq.ls, pair.left, state)) return false;
|
|
556
|
+
if (!this.canonizeList(eq.rs, pair.right, state)) return false;
|
|
557
|
+
newDeps = mkJoin(state.dep, newDeps);
|
|
558
|
+
const eqs: EqPair[] = [];
|
|
559
|
+
const isChanged = this.seqRewriter.reduceEqOf(pair, eqs);
|
|
560
|
+
if (isChanged === undefined) return true;
|
|
561
|
+
if (!isChanged) {
|
|
562
|
+
if (isUpdated) newEqs.push(eq);
|
|
563
|
+
continue;
|
|
564
|
+
}
|
|
565
|
+
if (!isUpdated) {
|
|
566
|
+
for (let previous = 0; previous < eqIndex; previous++) newEqs.push(ne.eqs[previous]);
|
|
567
|
+
isUpdated = true;
|
|
568
|
+
}
|
|
569
|
+
if (pair.left.length > 0 || pair.right.length > 0)
|
|
570
|
+
newEqs.push({
|
|
571
|
+
ls: pair.left.map((expr) => this.keep(expr)),
|
|
572
|
+
rs: pair.right.map((expr) => this.keep(expr)),
|
|
573
|
+
});
|
|
574
|
+
for (const newEq of eqs) {
|
|
575
|
+
if (this.isSeq(newEq.left) || this.isRe(newEq.left)) {
|
|
576
|
+
const ls = this.getConcatUnits(newEq.left, []).map((expr) => this.keep(expr));
|
|
577
|
+
const rs = this.getConcatUnits(newEq.right, []).map((expr) => this.keep(expr));
|
|
578
|
+
newEqs.push({ ls, rs });
|
|
579
|
+
} else if (newEq.left !== newEq.right) {
|
|
580
|
+
const literal = this.mkEqLiteral(newEq.left, newEq.right, false);
|
|
581
|
+
context.markLiteralAsRelevant(literal);
|
|
582
|
+
newLiterals.push(literal);
|
|
583
|
+
const value = context.getAssignment(literal);
|
|
584
|
+
if (value === L_FALSE) return true;
|
|
585
|
+
if (value === L_UNDEF) this.isNewPropagation = true;
|
|
586
|
+
}
|
|
587
|
+
}
|
|
588
|
+
}
|
|
589
|
+
if (isUpdated)
|
|
590
|
+
this.nqs.set(index, {
|
|
591
|
+
left: ne.left,
|
|
592
|
+
right: ne.right,
|
|
593
|
+
eqs: newEqs,
|
|
594
|
+
literals: newLiterals,
|
|
595
|
+
dep: newDeps,
|
|
596
|
+
});
|
|
597
|
+
return false;
|
|
598
|
+
}
|
|
599
|
+
|
|
600
|
+
protected branchNqs() {
|
|
601
|
+
for (let index = 0; index < this.nqs.size; index++) {
|
|
602
|
+
const result = this.branchNq(this.nqs.items[index]);
|
|
603
|
+
if (result === L_UNDEF) return true;
|
|
604
|
+
this.nqs.eraseAndSwap(index--);
|
|
605
|
+
if (result === L_FALSE) return true;
|
|
606
|
+
}
|
|
607
|
+
return false;
|
|
608
|
+
}
|
|
609
|
+
|
|
610
|
+
private branchNq(ne: Ne) {
|
|
611
|
+
const context = this.context;
|
|
612
|
+
const isLengthEqual = this.mkEqLiteral(this.mkLen(ne.left), this.mkLen(ne.right), false);
|
|
613
|
+
context.markLiteralAsRelevant(isLengthEqual);
|
|
614
|
+
const lengthValue = context.getAssignment(isLengthEqual);
|
|
615
|
+
if (lengthValue === L_FALSE) return L_TRUE;
|
|
616
|
+
if (lengthValue === L_UNDEF) return L_UNDEF;
|
|
617
|
+
const eq = this.mkEqLiteral(ne.left, ne.right, false);
|
|
618
|
+
const isNonEmpty = this.mkLiteralOf(this.mkArith(OP_GE, [this.mkLen(ne.left), this.mkInt(1)]));
|
|
619
|
+
context.markLiteralAsRelevant(isNonEmpty);
|
|
620
|
+
const nonEmptyValue = context.getAssignment(isNonEmpty);
|
|
621
|
+
if (nonEmptyValue === L_FALSE) {
|
|
622
|
+
this.addAxiomOf(eq, negate(isLengthEqual), isNonEmpty);
|
|
623
|
+
return L_FALSE;
|
|
624
|
+
}
|
|
625
|
+
if (nonEmptyValue === L_UNDEF) return L_UNDEF;
|
|
626
|
+
const first = this.mkDecompose(ne.left);
|
|
627
|
+
const second = this.mkDecompose(ne.right);
|
|
628
|
+
const isHeadEqual = this.mkEqLiteral(first.head, second.head, false);
|
|
629
|
+
context.markLiteralAsRelevant(isHeadEqual);
|
|
630
|
+
const headValue = context.getAssignment(isHeadEqual);
|
|
631
|
+
if (headValue === L_FALSE) return L_TRUE;
|
|
632
|
+
if (headValue === L_UNDEF) return L_UNDEF;
|
|
633
|
+
this.addAxiomOf(eq, negate(isLengthEqual), isNonEmpty);
|
|
634
|
+
this.addAxiomOf(
|
|
635
|
+
eq,
|
|
636
|
+
negate(isLengthEqual),
|
|
637
|
+
negate(isHeadEqual),
|
|
638
|
+
negate(this.mkEqLiteral(first.tail, second.tail, false)),
|
|
639
|
+
);
|
|
640
|
+
return L_FALSE;
|
|
641
|
+
}
|
|
642
|
+
|
|
643
|
+
private unfold(cell: Cell, cells: Cell[]) {
|
|
644
|
+
const manager = this.manager;
|
|
645
|
+
const found = this.rep.find1(cell.expr);
|
|
646
|
+
if (found !== undefined) {
|
|
647
|
+
this.unfold(
|
|
648
|
+
{ parent: cell, expr: found.expr, dep: mkJoin(found.dep, cell.dep), last: 0 },
|
|
649
|
+
cells,
|
|
650
|
+
);
|
|
651
|
+
} else if (this.isConcat(cell.expr)) {
|
|
652
|
+
this.unfold(
|
|
653
|
+
{ parent: cell, expr: manager.getArg(cell.expr, 0), dep: cell.dep, last: 0 },
|
|
654
|
+
cells,
|
|
655
|
+
);
|
|
656
|
+
this.unfold(
|
|
657
|
+
{ parent: undefined, expr: manager.getArg(cell.expr, 1), dep: null, last: 0 },
|
|
658
|
+
cells,
|
|
659
|
+
);
|
|
660
|
+
} else cells.push(cell);
|
|
661
|
+
cell.last = cells.length - 1;
|
|
662
|
+
}
|
|
663
|
+
|
|
664
|
+
private explainEq(firstExpr: number, secondExpr: number, inputDep: Dependency = null) {
|
|
665
|
+
if (firstExpr === secondExpr) return inputDep;
|
|
666
|
+
const manager = this.manager;
|
|
667
|
+
let dep = inputDep;
|
|
668
|
+
const firstCells: Cell[] = [];
|
|
669
|
+
const secondCells: Cell[] = [];
|
|
670
|
+
this.unfold({ parent: undefined, expr: firstExpr, dep: null, last: 0 }, firstCells);
|
|
671
|
+
this.unfold({ parent: undefined, expr: secondExpr, dep: null, last: 0 }, secondCells);
|
|
672
|
+
let first = 0;
|
|
673
|
+
let second = 0;
|
|
674
|
+
while (first < firstCells.length || second < secondCells.length) {
|
|
675
|
+
if (first === firstCells.length) {
|
|
676
|
+
while (second < secondCells.length && this.isEmpty(secondCells[second].expr))
|
|
677
|
+
dep = mkJoin(dep, secondCells[second++].dep);
|
|
678
|
+
return second === secondCells.length ? dep : undefined;
|
|
679
|
+
}
|
|
680
|
+
if (second === secondCells.length) {
|
|
681
|
+
while (first < firstCells.length && this.isEmpty(firstCells[first].expr))
|
|
682
|
+
dep = mkJoin(dep, firstCells[first++].dep);
|
|
683
|
+
return first === firstCells.length ? dep : undefined;
|
|
684
|
+
}
|
|
685
|
+
let firstCell = firstCells[first];
|
|
686
|
+
let secondCell = secondCells[second];
|
|
687
|
+
const left = firstCell.expr;
|
|
688
|
+
const right = secondCell.expr;
|
|
689
|
+
if (left === right) {
|
|
690
|
+
if (
|
|
691
|
+
firstCell.parent !== undefined &&
|
|
692
|
+
secondCell.parent !== undefined &&
|
|
693
|
+
firstCell.parent.expr === secondCell.parent.expr
|
|
694
|
+
) {
|
|
695
|
+
firstCell = firstCell.parent;
|
|
696
|
+
secondCell = secondCell.parent;
|
|
697
|
+
firstCells[firstCell.last] = firstCell;
|
|
698
|
+
first = firstCell.last;
|
|
699
|
+
secondCells[secondCell.last] = secondCell;
|
|
700
|
+
second = secondCell.last;
|
|
701
|
+
} else {
|
|
702
|
+
dep = mkJoin(mkJoin(dep, firstCell.dep), secondCell.dep);
|
|
703
|
+
first++;
|
|
704
|
+
second++;
|
|
705
|
+
}
|
|
706
|
+
} else if (this.isEmpty(left)) {
|
|
707
|
+
dep = mkJoin(dep, firstCell.dep);
|
|
708
|
+
first++;
|
|
709
|
+
} else if (this.isEmpty(right)) {
|
|
710
|
+
dep = mkJoin(dep, secondCell.dep);
|
|
711
|
+
second++;
|
|
712
|
+
} else if (this.isUnit(left) && this.isUnit(right)) {
|
|
713
|
+
const explained = this.explainEq(manager.getArg(left, 0), manager.getArg(right, 0), dep);
|
|
714
|
+
if (explained === undefined) return undefined;
|
|
715
|
+
dep = explained;
|
|
716
|
+
first++;
|
|
717
|
+
second++;
|
|
718
|
+
} else return undefined;
|
|
719
|
+
}
|
|
720
|
+
return dep;
|
|
721
|
+
}
|
|
722
|
+
|
|
723
|
+
protected isComplex(eq: DepEq) {
|
|
724
|
+
const numLeftVars = eq.ls.filter((expr) => this.isVar(expr)).length;
|
|
725
|
+
const numRightVars = eq.rs.filter((expr) => this.isVar(expr)).length;
|
|
726
|
+
return numLeftVars > 0 && numRightVars > 0 && numLeftVars + numRightVars > 2;
|
|
727
|
+
}
|
|
728
|
+
|
|
729
|
+
protected enforceLength(exprs: readonly number[], lengths: Rational[]) {
|
|
730
|
+
const manager = this.manager;
|
|
731
|
+
let isAllKnown = true;
|
|
732
|
+
for (const expr of exprs) {
|
|
733
|
+
const chars = manager.getString(expr);
|
|
734
|
+
const value = this.isUnit(expr)
|
|
735
|
+
? Rational.one
|
|
736
|
+
: this.isEmpty(expr)
|
|
737
|
+
? Rational.zero
|
|
738
|
+
: chars !== undefined
|
|
739
|
+
? Rational.of(BigInt(chars.length))
|
|
740
|
+
: this.getLengthValue(expr);
|
|
741
|
+
if (value !== undefined) lengths.push(value);
|
|
742
|
+
else {
|
|
743
|
+
this.addLengthToEqc(expr);
|
|
744
|
+
isAllKnown = false;
|
|
745
|
+
}
|
|
746
|
+
}
|
|
747
|
+
return isAllKnown;
|
|
748
|
+
}
|
|
749
|
+
|
|
750
|
+
protected branchVariable() {
|
|
751
|
+
if (this.branchTernaryVariable()) return true;
|
|
752
|
+
if (this.branchQuatVariable()) return true;
|
|
753
|
+
let isTurn = this.context.getRandomValue() % 2 === 0;
|
|
754
|
+
for (let index = 0; index < 2; index++, isTurn = !isTurn) {
|
|
755
|
+
if (isTurn && this.branchVariableMb()) return true;
|
|
756
|
+
if (!isTurn && this.branchVariableEq()) return true;
|
|
757
|
+
}
|
|
758
|
+
return false;
|
|
759
|
+
}
|
|
760
|
+
|
|
761
|
+
private branchVariableMb() {
|
|
762
|
+
let isChanged = false;
|
|
763
|
+
const size = this.eqs.size;
|
|
764
|
+
const start = this.context.getRandomValue();
|
|
765
|
+
for (let index = 0; index < size; index++) {
|
|
766
|
+
const eq = this.eqs.items[(index + start) % size];
|
|
767
|
+
if (!this.isComplex(eq)) continue;
|
|
768
|
+
if (
|
|
769
|
+
eq.ls.length === 0 ||
|
|
770
|
+
eq.rs.length === 0 ||
|
|
771
|
+
(!this.isVar(eq.ls[0]) && !this.isVar(eq.rs[0]))
|
|
772
|
+
)
|
|
773
|
+
continue;
|
|
774
|
+
const leftLengths: Rational[] = [];
|
|
775
|
+
const rightLengths: Rational[] = [];
|
|
776
|
+
if (!this.enforceLength(eq.ls, leftLengths) || !this.enforceLength(eq.rs, rightLengths))
|
|
777
|
+
continue;
|
|
778
|
+
const leftTotal = leftLengths.reduce((sum, length) => sum.add(length), Rational.zero);
|
|
779
|
+
const rightTotal = rightLengths.reduce((sum, length) => sum.add(length), Rational.zero);
|
|
780
|
+
if (
|
|
781
|
+
leftTotal.equals(rightTotal) &&
|
|
782
|
+
this.splitLengths(eq.dep, eq.ls, eq.rs, leftLengths, rightLengths)
|
|
783
|
+
) {
|
|
784
|
+
isChanged = true;
|
|
785
|
+
break;
|
|
786
|
+
}
|
|
787
|
+
const left = this.mkConcat(eq.ls);
|
|
788
|
+
const right = this.mkConcat(eq.rs);
|
|
789
|
+
if (this.propagateEq(eq.dep, [], this.mkLen(left), this.mkLen(right), false))
|
|
790
|
+
isChanged = true;
|
|
791
|
+
}
|
|
792
|
+
return isChanged;
|
|
793
|
+
}
|
|
794
|
+
|
|
795
|
+
private splitLengths(
|
|
796
|
+
dep: Dependency,
|
|
797
|
+
ls: readonly number[],
|
|
798
|
+
rs: readonly number[],
|
|
799
|
+
leftLengths: readonly Rational[],
|
|
800
|
+
rightLengths: readonly Rational[],
|
|
801
|
+
): boolean {
|
|
802
|
+
const context = this.context;
|
|
803
|
+
if (ls.length === 0 || rs.length === 0) return false;
|
|
804
|
+
if (this.isVar(ls[0]) && leftLengths[0].isZero()) return this.setEmpty(ls[0]);
|
|
805
|
+
if (this.isVar(rs[0]) && rightLengths[0].isZero()) return this.setEmpty(rs[0]);
|
|
806
|
+
if (this.isVar(rs[0]) && !this.isVar(ls[0]))
|
|
807
|
+
return this.splitLengths(dep, rs, ls, rightLengths, leftLengths);
|
|
808
|
+
if (!this.isVar(ls[0])) return false;
|
|
809
|
+
const variable = ls[0];
|
|
810
|
+
const variableLength = leftLengths[0];
|
|
811
|
+
const bs: number[] = [];
|
|
812
|
+
let prefixLength = Rational.zero;
|
|
813
|
+
let lastLength = Rational.zero;
|
|
814
|
+
for (let index = 0; variableLength.compare(prefixLength) > 0 && index < rs.length; index++) {
|
|
815
|
+
bs.push(rs[index]);
|
|
816
|
+
lastLength = rightLengths[index];
|
|
817
|
+
prefixLength = prefixLength.add(lastLength);
|
|
818
|
+
}
|
|
819
|
+
const last = bs.pop()!;
|
|
820
|
+
if (!this.isVar(last) && !this.isUnit(last)) return false;
|
|
821
|
+
if (variable === last) return false;
|
|
822
|
+
if (lastLength.isZero()) return this.setEmpty(last);
|
|
823
|
+
const prefix = this.mkConcat(bs, this.manager.sorts[variable]);
|
|
824
|
+
const variableLengthExpr = this.mkLen(variable);
|
|
825
|
+
const lastLengthExpr = this.mkLen(last);
|
|
826
|
+
const prefixLengthExpr = this.mkLen(prefix);
|
|
827
|
+
const isLonger = negate(this.mkLeLiteral(this.mkSub(variableLengthExpr, prefixLengthExpr), 0));
|
|
828
|
+
const isShorter = this.mkLeLiteral(
|
|
829
|
+
this.mkSub(this.mkSub(variableLengthExpr, prefixLengthExpr), lastLengthExpr),
|
|
830
|
+
0,
|
|
831
|
+
);
|
|
832
|
+
const literals = [isLonger, isShorter];
|
|
833
|
+
if (context.getAssignment(isLonger) !== L_TRUE || context.getAssignment(isShorter) !== L_TRUE) {
|
|
834
|
+
context.markLiteralAsRelevant(isLonger);
|
|
835
|
+
context.markLiteralAsRelevant(isShorter);
|
|
836
|
+
} else if (this.isUnit(last)) {
|
|
837
|
+
bs.push(last);
|
|
838
|
+
this.propagateEq(dep, literals, variable, this.mkConcat(bs, this.manager.sorts[last]), true);
|
|
839
|
+
} else {
|
|
840
|
+
const left = this.sk.mkLeft([variable, prefix, last]);
|
|
841
|
+
const right = this.sk.mkRight([variable, prefix, last]);
|
|
842
|
+
this.propagateEq(dep, literals, variable, this.mkConcat2(prefix, left), true);
|
|
843
|
+
this.propagateEq(dep, literals, last, this.mkConcat2(left, right), true);
|
|
844
|
+
}
|
|
845
|
+
return true;
|
|
846
|
+
}
|
|
847
|
+
|
|
848
|
+
protected branchBinaryVariable() {
|
|
849
|
+
return this.eqs.items.some((eq) => this.branchBinaryVariableOf(eq));
|
|
850
|
+
}
|
|
851
|
+
|
|
852
|
+
private branchBinaryVariableOf(eq: DepEq) {
|
|
853
|
+
const context = this.context;
|
|
854
|
+
if (this.isComplex(eq)) return false;
|
|
855
|
+
const match =
|
|
856
|
+
this.eqSolver.matchBinaryEq(eq.ls, eq.rs) ?? this.eqSolver.matchBinaryEq(eq.rs, eq.ls);
|
|
857
|
+
if (match === undefined || match.x === match.y) return false;
|
|
858
|
+
if (this.branchVariableEqOf(eq)) return true;
|
|
859
|
+
const xLength = this.getLengthValue(match.x);
|
|
860
|
+
if (xLength === undefined) {
|
|
861
|
+
this.addLengthToEqc(match.x);
|
|
862
|
+
return true;
|
|
863
|
+
}
|
|
864
|
+
const yLength = this.getLengthValue(match.y);
|
|
865
|
+
if (yLength === undefined) {
|
|
866
|
+
this.addLengthToEqc(match.y);
|
|
867
|
+
return true;
|
|
868
|
+
}
|
|
869
|
+
const xsSize = Rational.of(BigInt(match.xs.length));
|
|
870
|
+
const ysSize = Rational.of(BigInt(match.ys.length));
|
|
871
|
+
if (!xLength.add(xsSize).equals(yLength.add(ysSize))) {
|
|
872
|
+
const difference = this.mkSub(this.mkLen(match.x), this.mkLen(match.y));
|
|
873
|
+
const offset = this.mkInt(match.ys.length - match.xs.length);
|
|
874
|
+
this.propagateLit(eq.dep, [], this.mkEqLiteral(difference, offset, false));
|
|
875
|
+
return true;
|
|
876
|
+
}
|
|
877
|
+
if (xLength.compare(ysSize) <= 0) {
|
|
878
|
+
this.eqDeps = eq.dep;
|
|
879
|
+
if (this.eqSolver.branchUnitVariableOf(match.x, match.ys)) return true;
|
|
880
|
+
}
|
|
881
|
+
const literal = this.mkLiteralOf(
|
|
882
|
+
this.mkArith(OP_LE, [this.mkLen(match.x), this.mkInt(match.ys.length)]),
|
|
883
|
+
);
|
|
884
|
+
if (context.getAssignment(literal) === L_FALSE) {
|
|
885
|
+
const left = this.sk.mkLeft([match.x, match.y]);
|
|
886
|
+
const right = this.sk.mkRight([match.x, match.y]);
|
|
887
|
+
const ysLeft = this.mkConcat([...match.ys, left]);
|
|
888
|
+
const xs = this.mkConcat(match.xs);
|
|
889
|
+
const notLiteral = [negate(literal)];
|
|
890
|
+
this.propagateEq(eq.dep, notLiteral, match.x, ysLeft);
|
|
891
|
+
this.propagateEq(eq.dep, notLiteral, match.y, this.mkConcat2(left, right));
|
|
892
|
+
this.propagateEq(eq.dep, notLiteral, right, xs);
|
|
893
|
+
} else context.markLiteralAsRelevant(literal);
|
|
894
|
+
return true;
|
|
895
|
+
}
|
|
896
|
+
|
|
897
|
+
protected branchUnitVariable() {
|
|
898
|
+
for (const eq of this.eqs.items) {
|
|
899
|
+
this.eqDeps = eq.dep;
|
|
900
|
+
if (this.eqSolver.branchUnitVariable(eq.ls, eq.rs)) return true;
|
|
901
|
+
}
|
|
902
|
+
return false;
|
|
903
|
+
}
|
|
904
|
+
|
|
905
|
+
private branchTernaryVariable() {
|
|
906
|
+
return this.eqs.items.some(
|
|
907
|
+
(eq) => this.branchTernaryVariableRhs(eq) || this.branchTernaryVariableLhs(eq),
|
|
908
|
+
);
|
|
909
|
+
}
|
|
910
|
+
|
|
911
|
+
private canAlignOf(isFromLeft: boolean, ls: readonly number[], rs: readonly number[]) {
|
|
912
|
+
const pair = this.manager.mkApp(OP_EQ, [this.mkConcat(ls), this.mkConcat(rs)], SORT_BOOL);
|
|
913
|
+
const overlap = isFromLeft ? this.overlapLeft : this.overlapRight;
|
|
914
|
+
const cached = overlap.get(pair);
|
|
915
|
+
if (cached !== undefined) return cached;
|
|
916
|
+
const result = isFromLeft
|
|
917
|
+
? this.eqSolver.canAlignFromLhs(ls, rs)
|
|
918
|
+
: this.eqSolver.canAlignFromRhs(ls, rs);
|
|
919
|
+
overlap.set(this.keep(pair), result);
|
|
920
|
+
return result;
|
|
921
|
+
}
|
|
922
|
+
|
|
923
|
+
private ensureLengths(exprs: readonly number[]) {
|
|
924
|
+
for (const expr of exprs)
|
|
925
|
+
if (this.getLengthValue(expr) === undefined) this.addLengthToEqc(expr);
|
|
926
|
+
}
|
|
927
|
+
|
|
928
|
+
private branchTernaryVariableRhs(eq: DepEq) {
|
|
929
|
+
const match = this.eqSolver.matchTernaryEqRhs(eq.ls, eq.rs);
|
|
930
|
+
if (match === undefined) return false;
|
|
931
|
+
if (this.sk.isAlignL(match.y1) || this.sk.isAlignR(match.y1)) return false;
|
|
932
|
+
this.ensureLengths([match.x, match.y1, match.y2]);
|
|
933
|
+
if (this.canAlignOf(true, match.xs, match.ys)) return false;
|
|
934
|
+
const xs = this.mkConcat(match.xs);
|
|
935
|
+
const ys = this.mkConcat(match.ys);
|
|
936
|
+
const y1ys = this.mkConcat2(match.y1, ys);
|
|
937
|
+
const align = this.sk.mkAlignR([xs, match.y1, ys, match.y2]);
|
|
938
|
+
const dep = eq.dep;
|
|
939
|
+
let isPropagated = false;
|
|
940
|
+
if (this.propagateLit(dep, [], this.mkGeLiteral(this.mkLen(match.y2), match.xs.length)))
|
|
941
|
+
isPropagated = true;
|
|
942
|
+
const difference = this.mkSub(this.mkLen(match.x), this.mkLen(match.y1));
|
|
943
|
+
if (this.propagateLit(dep, [], this.mkGeLiteral(difference, match.ys.length)))
|
|
944
|
+
isPropagated = true;
|
|
945
|
+
if (this.propagateEq(dep, [], match.x, this.mkConcat2(y1ys, align), true)) isPropagated = true;
|
|
946
|
+
if (this.propagateEq(dep, [], match.y2, this.mkConcat2(align, xs), true)) isPropagated = true;
|
|
947
|
+
return isPropagated;
|
|
948
|
+
}
|
|
949
|
+
|
|
950
|
+
private branchTernaryVariableLhs(eq: DepEq) {
|
|
951
|
+
const match = this.eqSolver.matchTernaryEqLhs(eq.ls, eq.rs);
|
|
952
|
+
if (match === undefined) return false;
|
|
953
|
+
if (this.sk.isAlignL(match.y1) || this.sk.isAlignR(match.y1)) return false;
|
|
954
|
+
this.ensureLengths([match.x, match.y1, match.y2]);
|
|
955
|
+
if (this.canAlignOf(false, match.xs, match.ys)) return false;
|
|
956
|
+
const xs = this.mkConcat(match.xs);
|
|
957
|
+
const ys = this.mkConcat(match.ys);
|
|
958
|
+
const ysy2 = this.mkConcat2(ys, match.y2);
|
|
959
|
+
const align = this.sk.mkAlignL([xs, match.y1, ys, match.y2]);
|
|
960
|
+
const dep = eq.dep;
|
|
961
|
+
let isPropagated = false;
|
|
962
|
+
if (this.propagateLit(dep, [], this.mkGeLiteral(this.mkLen(match.y1), match.xs.length)))
|
|
963
|
+
isPropagated = true;
|
|
964
|
+
const difference = this.mkSub(this.mkLen(match.x), this.mkLen(match.y2));
|
|
965
|
+
if (this.propagateLit(dep, [], this.mkGeLiteral(difference, match.ys.length)))
|
|
966
|
+
isPropagated = true;
|
|
967
|
+
if (this.propagateEq(dep, [], match.x, this.mkConcat2(align, ysy2), true)) isPropagated = true;
|
|
968
|
+
if (this.propagateEq(dep, [], match.y1, this.mkConcat2(xs, align), true)) isPropagated = true;
|
|
969
|
+
return isPropagated;
|
|
970
|
+
}
|
|
971
|
+
|
|
972
|
+
private branchQuatVariable() {
|
|
973
|
+
return this.eqs.items.some((eq) => this.branchQuatVariableOf(eq));
|
|
974
|
+
}
|
|
975
|
+
|
|
976
|
+
private mkAlignment(first: number, second: number): Literal {
|
|
977
|
+
const manager = this.manager;
|
|
978
|
+
if (this.sk.isAlign(first) && this.sk.isAlign(second)) {
|
|
979
|
+
const firstPrefix = manager.getArg(first, 0);
|
|
980
|
+
const secondPrefix = manager.getArg(second, 0);
|
|
981
|
+
if (manager.getArg(first, 1) === manager.getArg(second, 1) && firstPrefix !== secondPrefix)
|
|
982
|
+
return this.mkAlignment(firstPrefix, secondPrefix);
|
|
983
|
+
}
|
|
984
|
+
return this.mkSimplifiedLiteral(
|
|
985
|
+
this.mkArith(OP_LE, [this.mkSub(this.mkLen(first), this.mkLen(second)), this.mkInt(0)]),
|
|
986
|
+
);
|
|
987
|
+
}
|
|
988
|
+
|
|
989
|
+
private branchQuatVariableOf(eq: DepEq) {
|
|
990
|
+
const context = this.context;
|
|
991
|
+
const match = this.eqSolver.matchQuatEq(eq.ls, eq.rs);
|
|
992
|
+
if (match === undefined) return false;
|
|
993
|
+
const dep = eq.dep;
|
|
994
|
+
this.ensureLengths([match.x1, match.y1, match.x2, match.y2]);
|
|
995
|
+
const isSame = isSameList(match.xs, match.ys);
|
|
996
|
+
let isCondition = false;
|
|
997
|
+
if (isSame) {
|
|
998
|
+
const xs1 = match.xs.slice(1);
|
|
999
|
+
const xs2 = match.xs.slice(0, -1);
|
|
1000
|
+
if (xs1.length === 0 || xs2.length === 0) isCondition = true;
|
|
1001
|
+
else if (!this.canAlignOf(true, xs2, match.ys) && !this.canAlignOf(false, xs1, match.ys))
|
|
1002
|
+
isCondition = true;
|
|
1003
|
+
} else if (
|
|
1004
|
+
!this.canAlignOf(true, match.xs, match.ys) &&
|
|
1005
|
+
!this.canAlignOf(false, match.xs, match.ys) &&
|
|
1006
|
+
!this.canAlignOf(true, match.ys, match.xs) &&
|
|
1007
|
+
!this.canAlignOf(false, match.ys, match.xs)
|
|
1008
|
+
)
|
|
1009
|
+
isCondition = true;
|
|
1010
|
+
if (!isCondition) return false;
|
|
1011
|
+
const literals: Literal[] = [];
|
|
1012
|
+
if (isSame) {
|
|
1013
|
+
const literal = this.mkEqLiteral(this.mkLen(match.x1), this.mkLen(match.y1), false);
|
|
1014
|
+
const value = context.getAssignment(literal);
|
|
1015
|
+
if (value === L_UNDEF) {
|
|
1016
|
+
context.markLiteralAsRelevant(literal);
|
|
1017
|
+
return true;
|
|
1018
|
+
}
|
|
1019
|
+
if (value === L_TRUE) {
|
|
1020
|
+
this.propagateEq(dep, [literal], match.x1, match.y1, true);
|
|
1021
|
+
this.propagateEq(dep, [literal], match.x2, match.y2, true);
|
|
1022
|
+
return true;
|
|
1023
|
+
}
|
|
1024
|
+
literals.push(negate(literal));
|
|
1025
|
+
}
|
|
1026
|
+
const isAligned = this.mkAlignment(match.x1, match.y1);
|
|
1027
|
+
const isRightLonger = this.mkGeLiteral(
|
|
1028
|
+
this.mkSub(this.mkLen(match.y1), this.mkLen(match.x1)),
|
|
1029
|
+
match.xs.length,
|
|
1030
|
+
);
|
|
1031
|
+
const isLeftLonger = this.mkGeLiteral(
|
|
1032
|
+
this.mkSub(this.mkLen(match.x1), this.mkLen(match.y1)),
|
|
1033
|
+
match.ys.length,
|
|
1034
|
+
);
|
|
1035
|
+
const aligned = context.getAssignment(isAligned);
|
|
1036
|
+
if (aligned === L_UNDEF) {
|
|
1037
|
+
context.markLiteralAsRelevant(isAligned);
|
|
1038
|
+
return true;
|
|
1039
|
+
}
|
|
1040
|
+
if (aligned === L_TRUE) {
|
|
1041
|
+
if (context.getAssignment(isRightLonger) === L_UNDEF) {
|
|
1042
|
+
context.markLiteralAsRelevant(isRightLonger);
|
|
1043
|
+
return true;
|
|
1044
|
+
}
|
|
1045
|
+
} else if (context.getAssignment(isLeftLonger) === L_UNDEF) {
|
|
1046
|
+
context.markLiteralAsRelevant(isLeftLonger);
|
|
1047
|
+
return true;
|
|
1048
|
+
}
|
|
1049
|
+
const xs = this.mkConcat(match.xs);
|
|
1050
|
+
const ys = this.mkConcat(match.ys);
|
|
1051
|
+
const x1xs = this.mkConcat2(match.x1, xs);
|
|
1052
|
+
const y1ys = this.mkConcat2(match.y1, ys);
|
|
1053
|
+
const xsx2 = this.mkConcat2(xs, match.x2);
|
|
1054
|
+
const ysy2 = this.mkConcat2(ys, match.y2);
|
|
1055
|
+
const rightLonger = context.getAssignment(isRightLonger);
|
|
1056
|
+
const leftLonger = context.getAssignment(isLeftLonger);
|
|
1057
|
+
if (aligned === L_TRUE && rightLonger === L_TRUE) {
|
|
1058
|
+
const align = this.sk.mkAlignM(match.y1, match.x1, xs, match.x2);
|
|
1059
|
+
this.propagateEq(dep, [isRightLonger], this.mkConcat2(x1xs, align), match.y1, true);
|
|
1060
|
+
this.propagateEq(dep, [isRightLonger], match.x2, this.mkConcat2(align, ysy2), true);
|
|
1061
|
+
return true;
|
|
1062
|
+
}
|
|
1063
|
+
if (aligned === L_FALSE && leftLonger === L_TRUE) {
|
|
1064
|
+
const align = this.sk.mkAlignM(match.x1, match.y1, ys, match.y2);
|
|
1065
|
+
this.propagateEq(dep, [isLeftLonger], match.x1, this.mkConcat2(y1ys, align), true);
|
|
1066
|
+
this.propagateEq(dep, [isLeftLonger], this.mkConcat2(align, xsx2), match.y2, true);
|
|
1067
|
+
return true;
|
|
1068
|
+
}
|
|
1069
|
+
if (aligned === L_FALSE && rightLonger === L_TRUE)
|
|
1070
|
+
return this.propagateLit(
|
|
1071
|
+
null,
|
|
1072
|
+
[...literals, negate(isAligned), isRightLonger],
|
|
1073
|
+
FALSE_LITERAL,
|
|
1074
|
+
);
|
|
1075
|
+
if (aligned === L_TRUE && leftLonger === L_TRUE)
|
|
1076
|
+
return this.propagateLit(null, [...literals, isAligned, isLeftLonger], FALSE_LITERAL);
|
|
1077
|
+
if (aligned === L_TRUE && rightLonger === L_FALSE)
|
|
1078
|
+
return this.propagateLit(dep, [...literals, isAligned, negate(isRightLonger)], FALSE_LITERAL);
|
|
1079
|
+
return this.propagateLit(
|
|
1080
|
+
dep,
|
|
1081
|
+
[...literals, negate(isAligned), negate(isLeftLonger)],
|
|
1082
|
+
FALSE_LITERAL,
|
|
1083
|
+
);
|
|
1084
|
+
}
|
|
1085
|
+
|
|
1086
|
+
private branchVariableEq() {
|
|
1087
|
+
const size = this.eqs.size;
|
|
1088
|
+
const start = this.context.getRandomValue();
|
|
1089
|
+
for (let index = 0; index < size; index++)
|
|
1090
|
+
if (this.branchVariableEqOf(this.eqs.items[(index + start) % size])) return true;
|
|
1091
|
+
return this.context.isInconsistent();
|
|
1092
|
+
}
|
|
1093
|
+
|
|
1094
|
+
private branchVariableEqOf(eq: DepEq) {
|
|
1095
|
+
const key = 2 * eq.id;
|
|
1096
|
+
const front = { start: this.branchStart.get(key) ?? 0 };
|
|
1097
|
+
let isFound = this.findBranchCandidate(front, eq.dep, eq.ls, eq.rs);
|
|
1098
|
+
this.insertBranchStart(key, front.start);
|
|
1099
|
+
if (!isFound) {
|
|
1100
|
+
const back = { start: this.branchStart.get(key + 1) ?? 0 };
|
|
1101
|
+
isFound = this.findBranchCandidate(back, eq.dep, eq.rs, eq.ls);
|
|
1102
|
+
this.insertBranchStart(key + 1, back.start);
|
|
1103
|
+
}
|
|
1104
|
+
return isFound;
|
|
1105
|
+
}
|
|
1106
|
+
|
|
1107
|
+
private insertBranchStart(key: number, start: number) {
|
|
1108
|
+
this.branchStart.set(key, start);
|
|
1109
|
+
this.trailStack.push(() => {
|
|
1110
|
+
this.branchStart.delete(key);
|
|
1111
|
+
});
|
|
1112
|
+
}
|
|
1113
|
+
|
|
1114
|
+
private findBranchCandidate(
|
|
1115
|
+
position: { start: number },
|
|
1116
|
+
dep: Dependency,
|
|
1117
|
+
ls: readonly number[],
|
|
1118
|
+
rs: readonly number[],
|
|
1119
|
+
) {
|
|
1120
|
+
const context = this.context;
|
|
1121
|
+
if (ls.length === 0) return false;
|
|
1122
|
+
const left = ls[0];
|
|
1123
|
+
if (!this.isVar(left)) return false;
|
|
1124
|
+
const rest = ls.slice(1);
|
|
1125
|
+
if (
|
|
1126
|
+
this.canBeEqual(rest, rs) &&
|
|
1127
|
+
this.assumeEquality(left, this.mkEmpty(this.manager.sorts[left]))
|
|
1128
|
+
)
|
|
1129
|
+
return true;
|
|
1130
|
+
for (; position.start < rs.length; position.start++) {
|
|
1131
|
+
const index = position.start;
|
|
1132
|
+
if (left === rs[index]) return false;
|
|
1133
|
+
if (!this.canBeEqual(rest, rs.slice(index + 1))) continue;
|
|
1134
|
+
if (this.assumeEquality(left, this.mkConcat(rs.slice(0, index + 1)))) {
|
|
1135
|
+
position.start++;
|
|
1136
|
+
return true;
|
|
1137
|
+
}
|
|
1138
|
+
}
|
|
1139
|
+
if (!rs.every((expr) => this.isUnit(expr))) return false;
|
|
1140
|
+
const literals = [negate(this.mkEqEmpty(left))];
|
|
1141
|
+
for (let index = 0; index < rs.length; index++)
|
|
1142
|
+
if (this.canBeEqual(rest, rs.slice(index + 1)))
|
|
1143
|
+
literals.push(negate(this.mkEqLiteral(left, this.mkConcat(rs.slice(0, index + 1)), false)));
|
|
1144
|
+
for (const literal of literals) {
|
|
1145
|
+
const value = context.getAssignment(literal);
|
|
1146
|
+
if (value === L_FALSE) {
|
|
1147
|
+
position.start = 0;
|
|
1148
|
+
return false;
|
|
1149
|
+
}
|
|
1150
|
+
if (value === L_UNDEF) {
|
|
1151
|
+
context.markLiteralAsRelevant(literal);
|
|
1152
|
+
context.forcePhase(negate(literal));
|
|
1153
|
+
position.start = 0;
|
|
1154
|
+
return true;
|
|
1155
|
+
}
|
|
1156
|
+
}
|
|
1157
|
+
this.setConflict(dep, literals);
|
|
1158
|
+
return true;
|
|
1159
|
+
}
|
|
1160
|
+
|
|
1161
|
+
private canBeEqual(inputLs: readonly number[], inputRs: readonly number[]) {
|
|
1162
|
+
const manager = this.manager;
|
|
1163
|
+
let ls = inputLs;
|
|
1164
|
+
let rs = inputRs;
|
|
1165
|
+
let index = 0;
|
|
1166
|
+
for (; index < ls.length && index < rs.length; index++) {
|
|
1167
|
+
if (manager.areDistinct(ls[index], rs[index])) return false;
|
|
1168
|
+
if (ls[index] !== rs[index]) break;
|
|
1169
|
+
}
|
|
1170
|
+
if (index === rs.length) {
|
|
1171
|
+
const swapped = ls;
|
|
1172
|
+
ls = rs;
|
|
1173
|
+
rs = swapped;
|
|
1174
|
+
}
|
|
1175
|
+
if (index === ls.length && index < rs.length)
|
|
1176
|
+
for (; index < rs.length; index++) if (this.isUnit(rs[index])) return false;
|
|
1177
|
+
return true;
|
|
1178
|
+
}
|
|
1179
|
+
|
|
1180
|
+
protected assumeEquality(left: number, right: number) {
|
|
1181
|
+
const context = this.context;
|
|
1182
|
+
const manager = this.manager;
|
|
1183
|
+
if (this.exclude.contains(left, right)) return false;
|
|
1184
|
+
const eq = this.rewrite(manager.mkApp(OP_EQ, [left, right], SORT_BOOL));
|
|
1185
|
+
if (eq === manager.trueExpr || eq === manager.falseExpr) return false;
|
|
1186
|
+
const first = this.ensureEnodeOf(left);
|
|
1187
|
+
const second = this.ensureEnodeOf(right);
|
|
1188
|
+
if (first.root === second.root || context.isDiseq(first, second)) return false;
|
|
1189
|
+
context.markAsRelevant(first.owner);
|
|
1190
|
+
context.markAsRelevant(second.owner);
|
|
1191
|
+
if (!context.assumeEq(first, second)) return false;
|
|
1192
|
+
return context.getAssignment(this.mkEqLiteral(left, right, false)) !== L_FALSE;
|
|
1193
|
+
}
|
|
1194
|
+
|
|
1195
|
+
private propagateLengthCoherence(expr: number) {
|
|
1196
|
+
if (!this.isVar(expr) || !this.rep.isRoot(expr)) return false;
|
|
1197
|
+
const lower = this.lowerBound2(expr);
|
|
1198
|
+
if (lower === undefined || !lower.isPositive() || lower.compare(Rational.of(2048n)) >= 0)
|
|
1199
|
+
return false;
|
|
1200
|
+
const elems: number[] = [];
|
|
1201
|
+
let seq = expr;
|
|
1202
|
+
for (let index = 0n; index < lower.num; index++) {
|
|
1203
|
+
const decomposition = this.decompose(seq);
|
|
1204
|
+
elems.push(decomposition.head);
|
|
1205
|
+
seq = decomposition.tail;
|
|
1206
|
+
}
|
|
1207
|
+
const empty = this.mkEmpty(this.manager.sorts[expr]);
|
|
1208
|
+
elems.push(seq);
|
|
1209
|
+
const tail = this.mkConcat(elems);
|
|
1210
|
+
const isAtLeast = this.mkLiteralOf(
|
|
1211
|
+
this.mkArith(OP_GE, [this.mkLen(expr), this.manager.mkNumeral(lower.num)]),
|
|
1212
|
+
);
|
|
1213
|
+
const eq = this.mkSeqEq(expr, tail);
|
|
1214
|
+
let isAdded = false;
|
|
1215
|
+
if (this.context.getAssignment(eq) !== L_TRUE) {
|
|
1216
|
+
this.addAxiomOf(negate(isAtLeast), eq);
|
|
1217
|
+
isAdded = true;
|
|
1218
|
+
}
|
|
1219
|
+
const length = this.mkLen(expr);
|
|
1220
|
+
const upper = this.upperBound(length);
|
|
1221
|
+
if (upper === undefined) return this.assumeEquality(seq, empty) || isAdded;
|
|
1222
|
+
const isAtMost = this.mkArith(OP_LE, [length, this.manager.mkNumeral(upper.num)]);
|
|
1223
|
+
if (upper.equals(lower)) {
|
|
1224
|
+
this.addAxiomOf(
|
|
1225
|
+
negate(isAtLeast),
|
|
1226
|
+
negate(this.mkLiteralOf(isAtMost)),
|
|
1227
|
+
this.mkSeqEq(seq, empty),
|
|
1228
|
+
);
|
|
1229
|
+
return true;
|
|
1230
|
+
}
|
|
1231
|
+
const isRestShort = this.mkLiteralOf(
|
|
1232
|
+
this.mkArith(OP_LE, [this.mkLen(seq), this.manager.mkNumeral(upper.sub(lower).num)]),
|
|
1233
|
+
);
|
|
1234
|
+
if (this.context.getAssignment(isRestShort) !== L_TRUE) {
|
|
1235
|
+
this.addAxiomOf(negate(isAtLeast), negate(this.mkLiteralOf(isAtMost)), isRestShort);
|
|
1236
|
+
isAdded = true;
|
|
1237
|
+
}
|
|
1238
|
+
return isAdded;
|
|
1239
|
+
}
|
|
1240
|
+
|
|
1241
|
+
protected checkLengthCoherenceOf(expr: number) {
|
|
1242
|
+
if (!this.isVar(expr) || !this.rep.isRoot(expr)) return false;
|
|
1243
|
+
if (!this.checkLengthCoherence0(expr)) {
|
|
1244
|
+
const empty = this.mkEmpty(this.manager.sorts[expr]);
|
|
1245
|
+
const decomposition = this.decompose(expr);
|
|
1246
|
+
const conc = this.mkConcat2(decomposition.head, decomposition.tail);
|
|
1247
|
+
if (this.propagateIsConc(expr, conc)) this.assumeEquality(decomposition.tail, empty);
|
|
1248
|
+
}
|
|
1249
|
+
return true;
|
|
1250
|
+
}
|
|
1251
|
+
|
|
1252
|
+
private checkLengthCoherence0(expr: number) {
|
|
1253
|
+
if (!this.isVar(expr) || !this.rep.isRoot(expr)) return false;
|
|
1254
|
+
const empty = this.mkEmpty(this.manager.sorts[expr]);
|
|
1255
|
+
if (!this.propagateLengthCoherence(expr) && !this.assumeEquality(expr, empty)) return false;
|
|
1256
|
+
if (this.context.scopeLevel !== this.context.baseLevel) {
|
|
1257
|
+
const kept = this.keep(expr);
|
|
1258
|
+
this.trailStack.push(() => {
|
|
1259
|
+
this.replay.push(() => {
|
|
1260
|
+
this.checkLengthCoherenceOf(kept);
|
|
1261
|
+
});
|
|
1262
|
+
});
|
|
1263
|
+
}
|
|
1264
|
+
return true;
|
|
1265
|
+
}
|
|
1266
|
+
|
|
1267
|
+
private propagateIsConc(expr: number, conc: number) {
|
|
1268
|
+
const literal = negate(this.mkEqEmpty(expr));
|
|
1269
|
+
if (this.context.getAssignment(literal) !== L_TRUE) return false;
|
|
1270
|
+
this.propagateLit(null, [literal], this.mkEqLiteral(expr, conc, false));
|
|
1271
|
+
this.newEqEhOf(
|
|
1272
|
+
this.mkLiteralLeaf(literal),
|
|
1273
|
+
this.context.getEnode(expr)!,
|
|
1274
|
+
this.context.getEnode(conc)!,
|
|
1275
|
+
);
|
|
1276
|
+
return true;
|
|
1277
|
+
}
|
|
1278
|
+
|
|
1279
|
+
protected checkLengthCoherence() {
|
|
1280
|
+
const numLengths = this.lengths.length;
|
|
1281
|
+
for (let index = 0; index < numLengths; index++)
|
|
1282
|
+
if (this.checkLengthCoherence0(this.manager.getArg(this.lengths[index], 0))) return true;
|
|
1283
|
+
let isChanged = false;
|
|
1284
|
+
const size = this.lengths.length;
|
|
1285
|
+
for (let index = 0; index < size; index++) {
|
|
1286
|
+
const expr = this.manager.getArg(this.lengths[index], 0);
|
|
1287
|
+
if (this.checkLengthCoherenceOf(expr)) return true;
|
|
1288
|
+
if (!this.context.isEInternalized(expr)) isChanged = true;
|
|
1289
|
+
const node = this.ensureEnodeOf(expr);
|
|
1290
|
+
if (node.root !== node && this.hasLength(node.root.owner)) continue;
|
|
1291
|
+
if (this.addLengthToEqc(expr)) isChanged = true;
|
|
1292
|
+
}
|
|
1293
|
+
return isChanged;
|
|
1294
|
+
}
|
|
1295
|
+
|
|
1296
|
+
protected reduceLengthEq() {
|
|
1297
|
+
const start = this.context.getRandomValue();
|
|
1298
|
+
for (let index = 0; !this.context.isInconsistent() && index < this.eqs.size; index++) {
|
|
1299
|
+
const eq = this.eqs.items[(index + start) % this.eqs.size];
|
|
1300
|
+
if (this.reduceLengthEqOf(eq.ls, eq.rs, eq.dep)) return true;
|
|
1301
|
+
}
|
|
1302
|
+
return false;
|
|
1303
|
+
}
|
|
1304
|
+
|
|
1305
|
+
protected checkExtensionalityOf(canonical: number, first: Enode, second: Enode) {
|
|
1306
|
+
const firstExpr = first.owner;
|
|
1307
|
+
const secondExpr = second.owner;
|
|
1308
|
+
const manager = this.manager;
|
|
1309
|
+
if (manager.sorts[firstExpr] !== manager.sorts[secondExpr]) return true;
|
|
1310
|
+
if (this.context.isDiseq(first, second) || this.exclude.contains(firstExpr, secondExpr))
|
|
1311
|
+
return true;
|
|
1312
|
+
const other = this.canonize(secondExpr, { dep: null, isChanged: false });
|
|
1313
|
+
if (other === undefined) return false;
|
|
1314
|
+
const eqs: EqPair[] = [];
|
|
1315
|
+
if (this.seqRewriter.reduceEq(canonical, other, eqs) === undefined) {
|
|
1316
|
+
this.exclude.update(this.keep(firstExpr), this.keep(secondExpr));
|
|
1317
|
+
return true;
|
|
1318
|
+
}
|
|
1319
|
+
if (eqs.some((eq) => this.exclude.contains(eq.left, eq.right))) return true;
|
|
1320
|
+
this.context.assumeEq(first, second);
|
|
1321
|
+
return false;
|
|
1322
|
+
}
|
|
1323
|
+
|
|
1324
|
+
protected checkExtensionality() {
|
|
1325
|
+
const context = this.context;
|
|
1326
|
+
const size = this.getNumVars();
|
|
1327
|
+
const seqs: number[] = [];
|
|
1328
|
+
for (let thVar = 0; thVar < size; thVar++) {
|
|
1329
|
+
const node = this.getEnode(thVar);
|
|
1330
|
+
const expr = node.owner;
|
|
1331
|
+
if (this.isNthU(expr) && node.isCgr()) {
|
|
1332
|
+
const firstRoot = node.getArg(0).root;
|
|
1333
|
+
const secondRoot = node.getArg(1).root;
|
|
1334
|
+
const canonical = this.canonize(firstRoot.owner, { dep: null, isChanged: false });
|
|
1335
|
+
if (canonical === undefined) return false;
|
|
1336
|
+
for (const parent of secondRoot.parents)
|
|
1337
|
+
if (
|
|
1338
|
+
parent !== node &&
|
|
1339
|
+
parent.isCgr() &&
|
|
1340
|
+
this.isNthU(parent.owner) &&
|
|
1341
|
+
!this.checkExtensionalityOf(canonical, firstRoot, parent.getArg(0).root)
|
|
1342
|
+
)
|
|
1343
|
+
return false;
|
|
1344
|
+
}
|
|
1345
|
+
if (node.root !== node || !this.isSeq(expr)) continue;
|
|
1346
|
+
if (seqs.length > 0 && context.isRelevant(expr) && context.isShared(node)) {
|
|
1347
|
+
const canonical = this.canonize(expr, { dep: null, isChanged: false });
|
|
1348
|
+
if (canonical === undefined) return false;
|
|
1349
|
+
for (const other of seqs)
|
|
1350
|
+
if (!this.checkExtensionalityOf(canonical, node, this.getEnode(other))) return false;
|
|
1351
|
+
}
|
|
1352
|
+
seqs.push(thVar);
|
|
1353
|
+
}
|
|
1354
|
+
return true;
|
|
1355
|
+
}
|
|
1356
|
+
|
|
1357
|
+
protected newEqEhOf(dep: Dependency, first: Enode, second: Enode) {
|
|
1358
|
+
const firstExpr = first.owner;
|
|
1359
|
+
if (first === second || !this.isSeq(firstExpr)) return;
|
|
1360
|
+
const firstVar = first.getThVar(this.id);
|
|
1361
|
+
const secondVar = second.getThVar(this.id);
|
|
1362
|
+
if (firstVar < 0 || secondVar < 0) return;
|
|
1363
|
+
if (this.unionFind.find(firstVar) === this.unionFind.find(secondVar)) return;
|
|
1364
|
+
this.unionFind.merge(firstVar, secondVar);
|
|
1365
|
+
this.eqs.push(this.mkEqDep(firstExpr, second.owner, dep));
|
|
1366
|
+
this.solveEqs(this.eqs.size - 1);
|
|
1367
|
+
this.enforceLengthCoherence(first, second);
|
|
1368
|
+
}
|
|
1369
|
+
|
|
1370
|
+
protected getMinLength(expr: number) {
|
|
1371
|
+
return getMinLengthOf(this.manager, expr);
|
|
1372
|
+
}
|
|
1373
|
+
}
|