tla-ts 0.0.4-dev.a0009b7 → 0.0.4-dev.a11a30a
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 +32 -143
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +35 -1
- package/dist/index.d.ts +35 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +996 -0
- package/dist/prove.js +996 -0
- package/dist/run-cli.cjs +37 -47
- package/dist/run-cli.js +37 -47
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +38 -44
- package/dist/transfer.js +38 -44
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/check.ts +1 -0
- package/src/codegen.ts +26 -7
- package/src/errors.ts +86 -0
- package/src/evaluate.ts +63 -20
- package/src/index.ts +10 -0
- package/src/{obligation-action.ts → obligations/action.ts} +247 -69
- package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
- package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
- package/src/{obligations.ts → obligations/index.ts} +32 -16
- package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
- package/src/{obligation-module.ts → obligations/module.ts} +113 -121
- package/src/obligations/pickle.ts +98 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/{obligation-source.ts → obligations/source.ts} +154 -99
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +2 -18
- package/src/parallel.ts +10 -43
- package/src/prove/decide-pool.ts +95 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/first-order.ts +78 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +446 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +547 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +441 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +363 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +402 -0
- package/src/prove/isabelle/pure/name.ts +110 -0
- package/src/prove/isabelle/pure/net.ts +262 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +650 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +156 -0
- package/src/prove/isabelle/pure/simplifier.ts +112 -0
- package/src/prove/isabelle/pure/table.ts +208 -0
- package/src/prove/isabelle/pure/tactic.ts +276 -0
- package/src/prove/isabelle/pure/tactical.ts +347 -0
- package/src/prove/isabelle/pure/term-ord.ts +159 -0
- package/src/prove/isabelle/pure/term.ts +808 -0
- package/src/prove/isabelle/pure/thm.ts +806 -0
- package/src/prove/isabelle/pure/type.ts +133 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +508 -0
- package/src/prove/prep/defs.ts +33 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +529 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +22 -0
- package/src/prove/prove.ts +498 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +255 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +209 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +164 -0
- package/src/prove/smt/extensionality.ts +65 -0
- package/src/prove/smt/flatten.ts +112 -0
- package/src/prove/smt/format.ts +154 -0
- package/src/prove/smt/instances.ts +181 -0
- package/src/prove/smt/rewrite.ts +772 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +147 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +96 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +18 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +379 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +181 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/run-cli.ts +283 -81
- package/src/standard-modules.ts +5 -2
- package/src/successors.ts +24 -5
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-random.ts +55 -32
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +97 -47
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,715 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/monomial_bounds.{h,cpp}, src/util/mpq.h root), MIT license, see
|
|
2
|
+
// z3-license.txt. Bounds of monomials from the intervals of their factors and back, the
|
|
3
|
+
// linearization of monomials with at most one non-fixed factor, and the optimization of the bounds
|
|
4
|
+
// of nonlinear variables over the tableau. The shared-factor and binomial-sign lemmas, off by
|
|
5
|
+
// default (arith.nl.monomial_sandwich, arith.nl.monomial_binomial_sign), are not ported.
|
|
6
|
+
import { getLcm, Rational } from "../rational";
|
|
7
|
+
import { type ConstraintKind, KIND_EQ, KIND_GE, KIND_GT, KIND_LE, KIND_LT } from "./constraints";
|
|
8
|
+
import {
|
|
9
|
+
DepInterval,
|
|
10
|
+
div,
|
|
11
|
+
mkDepInterval,
|
|
12
|
+
mul,
|
|
13
|
+
power,
|
|
14
|
+
separatedFromZero,
|
|
15
|
+
set,
|
|
16
|
+
setValue,
|
|
17
|
+
} from "./dep-intervals";
|
|
18
|
+
import { LP_INFEASIBLE } from "./core-solver";
|
|
19
|
+
import { Dependency, linearize, mkJoin } from "./dependency";
|
|
20
|
+
import { Explanation } from "./explanation";
|
|
21
|
+
import { NULL_LPVAR } from "./lar-solver";
|
|
22
|
+
import { Impq } from "./numeric-pair";
|
|
23
|
+
import { NLA_PARAMS, type NlaCore } from "./nla-core";
|
|
24
|
+
import { LemmaBuilder } from "./nla-types";
|
|
25
|
+
import type { Monic } from "./nla-emonics";
|
|
26
|
+
|
|
27
|
+
interface Gain {
|
|
28
|
+
isUnbounded: boolean;
|
|
29
|
+
minGain: Rational;
|
|
30
|
+
maxGain: Impq;
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
interface ImprovedBound {
|
|
34
|
+
readonly column: number;
|
|
35
|
+
readonly kind: ConstraintKind;
|
|
36
|
+
readonly bound: Rational;
|
|
37
|
+
readonly dep: Dependency;
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
const getAbs = (value: Impq) =>
|
|
41
|
+
value.x.isNegative() || (value.x.isZero() && value.y.isNegative()) ? value.neg() : value;
|
|
42
|
+
|
|
43
|
+
// normalize_gain: rounds a value down to a multiple of an integral divisor, -1 meaning none.
|
|
44
|
+
const roundDown = (value: Impq, divisor: Rational) => {
|
|
45
|
+
if (divisor.equals(Rational.one)) return new Impq(value.floor());
|
|
46
|
+
if (divisor.equals(Rational.minusOne)) return value;
|
|
47
|
+
return new Impq(value.div(divisor).floor().mul(divisor));
|
|
48
|
+
};
|
|
49
|
+
|
|
50
|
+
export class MonomialBounds {
|
|
51
|
+
constructor(private core: NlaCore) {}
|
|
52
|
+
|
|
53
|
+
// generate_lemmas: with the sandwich and binomial-sign lemmas off, the conflict of an infeasible
|
|
54
|
+
// lp solver, once some monic needs refinement.
|
|
55
|
+
generateLemmas() {
|
|
56
|
+
if (this.core.toRefine.size > 0) this.addLemma();
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
private computeProduct(start: number, monic: Monic, product: DepInterval) {
|
|
60
|
+
const interval = mkDepInterval();
|
|
61
|
+
for (let index = start; index < monic.size;) {
|
|
62
|
+
const lpVar = monic.vars[index];
|
|
63
|
+
this.varToInterval(lpVar, interval);
|
|
64
|
+
index++;
|
|
65
|
+
let exponent = 1;
|
|
66
|
+
for (; index < monic.size && monic.vars[index] === lpVar; index++) exponent++;
|
|
67
|
+
power(interval, exponent, interval, "with-deps");
|
|
68
|
+
mul(product, interval, product, "with-deps");
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
private varToInterval(lpVar: number, interval: DepInterval) {
|
|
73
|
+
const lra = this.core.lra;
|
|
74
|
+
const lower = lra.getBound(lpVar, false);
|
|
75
|
+
if (lower !== undefined) {
|
|
76
|
+
interval.isLowerOpen = lower.isStrict;
|
|
77
|
+
interval.lower = lower.value;
|
|
78
|
+
interval.lowerDep = lower.dep;
|
|
79
|
+
interval.isLowerInf = false;
|
|
80
|
+
} else interval.isLowerInf = true;
|
|
81
|
+
const upper = lra.getBound(lpVar, true);
|
|
82
|
+
if (upper !== undefined) {
|
|
83
|
+
interval.isUpperOpen = upper.isStrict;
|
|
84
|
+
interval.upper = upper.value;
|
|
85
|
+
interval.upperDep = upper.dep;
|
|
86
|
+
interval.isUpperInf = false;
|
|
87
|
+
} else interval.isUpperInf = true;
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
// tighten_lp: the bounds of the factors from the monic's interval, and of the monic from theirs.
|
|
91
|
+
private tightenLp(monic: Monic) {
|
|
92
|
+
const analysis = this.analyzeMonomial(monic);
|
|
93
|
+
const isPropagatingUp = analysis.numFree === 0;
|
|
94
|
+
const isPropagatingDown = !this.isFree(monic.variable) && analysis.numFree <= 1;
|
|
95
|
+
if (!isPropagatingUp && !isPropagatingDown) return false;
|
|
96
|
+
const product = mkDepInterval();
|
|
97
|
+
const interval = mkDepInterval();
|
|
98
|
+
const monicInterval = mkDepInterval();
|
|
99
|
+
const otherProduct = mkDepInterval();
|
|
100
|
+
this.varToInterval(monic.variable, monicInterval);
|
|
101
|
+
setValue(product, Rational.one);
|
|
102
|
+
let isTightened = false;
|
|
103
|
+
for (let index = 0; index < monic.size;) {
|
|
104
|
+
const lpVar = monic.vars[index];
|
|
105
|
+
index++;
|
|
106
|
+
let exponent = 1;
|
|
107
|
+
for (; index < monic.size && lpVar === monic.vars[index]; index++) exponent++;
|
|
108
|
+
this.varToInterval(lpVar, interval);
|
|
109
|
+
power(interval, exponent, interval, "with-deps");
|
|
110
|
+
if (isPropagatingDown && (analysis.numFree === 0 || analysis.freeVar === lpVar)) {
|
|
111
|
+
set(otherProduct, product, "with-deps");
|
|
112
|
+
this.computeProduct(index, monic, otherProduct);
|
|
113
|
+
if (this.tightenLpBoundByDivision(monicInterval, lpVar, exponent, otherProduct))
|
|
114
|
+
isTightened = true;
|
|
115
|
+
}
|
|
116
|
+
mul(product, interval, product, "with-deps");
|
|
117
|
+
}
|
|
118
|
+
if (!isPropagatingUp) return isTightened;
|
|
119
|
+
return this.tightenLpBound(product, monic.variable, 1) || isTightened;
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
private tightenLpBoundByDivision(
|
|
123
|
+
monicInterval: DepInterval,
|
|
124
|
+
lpVar: number,
|
|
125
|
+
exponent: number,
|
|
126
|
+
product: DepInterval,
|
|
127
|
+
) {
|
|
128
|
+
if (!separatedFromZero(product)) return false;
|
|
129
|
+
const range = mkDepInterval();
|
|
130
|
+
div(monicInterval, product, range, "with-deps");
|
|
131
|
+
return this.tightenLpBound(range, lpVar, exponent);
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
private isFree(lpVar: number) {
|
|
135
|
+
return !this.core.hasLowerBound(lpVar) && !this.core.hasUpperBound(lpVar);
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
private isZero(lpVar: number) {
|
|
139
|
+
const core = this.core;
|
|
140
|
+
return (
|
|
141
|
+
core.hasLowerBound(lpVar) &&
|
|
142
|
+
core.hasUpperBound(lpVar) &&
|
|
143
|
+
core.getLowerBound(lpVar).isZero() &&
|
|
144
|
+
core.getUpperBound(lpVar).isZero()
|
|
145
|
+
);
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
// analyze_monomial: the number of free variables of odd degree, and the last of them.
|
|
149
|
+
private analyzeMonomial(monic: Monic) {
|
|
150
|
+
let numFree = 0;
|
|
151
|
+
let freeVar = -1;
|
|
152
|
+
for (let index = 0; index < monic.vars.length;) {
|
|
153
|
+
const lpVar = monic.vars[index];
|
|
154
|
+
index++;
|
|
155
|
+
let exponent = 1;
|
|
156
|
+
for (; index < monic.vars.length && monic.vars[index] === lpVar; index++) exponent++;
|
|
157
|
+
if (this.isZero(lpVar)) return { numFree: 0, freeVar };
|
|
158
|
+
if (exponent % 2 === 1 && this.isFree(lpVar)) {
|
|
159
|
+
numFree++;
|
|
160
|
+
freeVar = lpVar;
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
return { numFree, freeVar };
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
propagateChangedBounds() {
|
|
167
|
+
const core = this.core;
|
|
168
|
+
let isPropagated = false;
|
|
169
|
+
for (const lpVar of core.monicsWithChangedBounds.elems) {
|
|
170
|
+
if (!core.isMonicVar(lpVar)) continue;
|
|
171
|
+
const monic = core.emon(lpVar);
|
|
172
|
+
if (this.propagateLinearBound(monic)) isPropagated = true;
|
|
173
|
+
if (this.tightenLp(monic)) isPropagated = true;
|
|
174
|
+
if (core.lra.status === LP_INFEASIBLE) break;
|
|
175
|
+
}
|
|
176
|
+
return isPropagated;
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
// add_lemma: a conflict lemma when the lp solver is infeasible.
|
|
180
|
+
private addLemma() {
|
|
181
|
+
const lra = this.core.lra;
|
|
182
|
+
if (lra.status !== LP_INFEASIBLE) return false;
|
|
183
|
+
const explanation = new Explanation();
|
|
184
|
+
lra.getInfeasibilityExplanation(explanation);
|
|
185
|
+
new LemmaBuilder(this.core).addExplanation(explanation);
|
|
186
|
+
return true;
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
private propagateLinearBound(monic: Monic) {
|
|
190
|
+
if (monic.isPropagated) return false;
|
|
191
|
+
const linear = this.getLinear(monic);
|
|
192
|
+
if (linear === undefined) return false;
|
|
193
|
+
this.core.emons.setPropagated(monic);
|
|
194
|
+
return this.linearize(monic, linear.nonFixed, linear.fixedToZero);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
private linearize(monic: Monic, nonFixed: number, fixedToZero: number) {
|
|
198
|
+
let isPropagated: boolean;
|
|
199
|
+
if (fixedToZero !== -1) isPropagated = this.propagateFixedToZero(monic, fixedToZero);
|
|
200
|
+
else {
|
|
201
|
+
const product = this.getFixedVarProduct(monic, nonFixed);
|
|
202
|
+
isPropagated =
|
|
203
|
+
nonFixed === -1
|
|
204
|
+
? this.propagateFixed(monic, product)
|
|
205
|
+
: this.propagateNonfixed(monic, product, nonFixed);
|
|
206
|
+
}
|
|
207
|
+
if (isPropagated) this.core.stats.nlaPropagateEq++;
|
|
208
|
+
return isPropagated;
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
// propagate_violated_linear_monomials: the defining rows of violated monomials with at most one
|
|
212
|
+
// non-fixed factor, except for small fixed products, which branching enumerates.
|
|
213
|
+
propagateViolatedLinearMonomials() {
|
|
214
|
+
const core = this.core;
|
|
215
|
+
if (!NLA_PARAMS.linearizeViolatedMonomials || !core.lra.isFeasible()) return false;
|
|
216
|
+
let isPropagated = false;
|
|
217
|
+
for (const monic of core.emons.monics) {
|
|
218
|
+
if (core.checkMonic(monic)) continue;
|
|
219
|
+
const linear = this.getLinear(monic);
|
|
220
|
+
if (linear === undefined) continue;
|
|
221
|
+
if (linear.fixedToZero === -1 && linear.nonFixed !== -1) {
|
|
222
|
+
const product = this.getFixedVarProduct(monic, linear.nonFixed);
|
|
223
|
+
if (product.isInt() && getBitSize(product) <= 16) continue;
|
|
224
|
+
}
|
|
225
|
+
if (this.linearize(monic, linear.nonFixed, linear.fixedToZero)) isPropagated = true;
|
|
226
|
+
if (core.lra.status === LP_INFEASIBLE) break;
|
|
227
|
+
}
|
|
228
|
+
return isPropagated;
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
private getExplanation(dep: Dependency) {
|
|
232
|
+
const explanation = new Explanation();
|
|
233
|
+
for (const constraint of linearize([dep])) explanation.addPair(constraint, Rational.one);
|
|
234
|
+
return explanation;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
private propagateFixedToZero(monic: Monic, fixedToZero: number) {
|
|
238
|
+
const core = this.core;
|
|
239
|
+
if (core.varIsFixedToZero(monic.variable)) return false;
|
|
240
|
+
const dep = core.lra.getBoundWitnesses(fixedToZero);
|
|
241
|
+
core.lra.updateColumnTypeAndBound(monic.variable, KIND_EQ, Impq.zero, dep);
|
|
242
|
+
core.fixedEqualities.push({
|
|
243
|
+
lpVar: monic.variable,
|
|
244
|
+
value: Rational.zero,
|
|
245
|
+
explanation: this.getExplanation(dep),
|
|
246
|
+
});
|
|
247
|
+
return true;
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
private propagateFixed(monic: Monic, value: Rational) {
|
|
251
|
+
const core = this.core;
|
|
252
|
+
if (core.varIsFixed(monic.variable) && core.getLowerBound(monic.variable).equals(value))
|
|
253
|
+
return false;
|
|
254
|
+
const dep = this.explainFixed(monic, value);
|
|
255
|
+
core.lra.updateColumnTypeAndBound(monic.variable, KIND_EQ, new Impq(value), dep);
|
|
256
|
+
core.fixedEqualities.push({
|
|
257
|
+
lpVar: monic.variable,
|
|
258
|
+
value,
|
|
259
|
+
explanation: this.getExplanation(dep),
|
|
260
|
+
});
|
|
261
|
+
return true;
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
// propagate_nonfixed: the row m - k * w = 0.
|
|
265
|
+
private propagateNonfixed(monic: Monic, coeff: Rational, nonFixed: number) {
|
|
266
|
+
const core = this.core;
|
|
267
|
+
if (core.val(monic.variable).equals(coeff.mul(core.val(nonFixed)))) return false;
|
|
268
|
+
const column = core.lra.addTerm(
|
|
269
|
+
[
|
|
270
|
+
[nonFixed, coeff.neg()],
|
|
271
|
+
[monic.variable, Rational.one],
|
|
272
|
+
],
|
|
273
|
+
NULL_LPVAR,
|
|
274
|
+
);
|
|
275
|
+
const dep = this.explainFixed(monic, coeff);
|
|
276
|
+
core.lra.updateColumnTypeAndBound(column, KIND_EQ, Impq.zero, dep);
|
|
277
|
+
if (coeff.equals(Rational.one))
|
|
278
|
+
core.equalities.push({
|
|
279
|
+
first: monic.variable,
|
|
280
|
+
second: nonFixed,
|
|
281
|
+
explanation: this.getExplanation(dep),
|
|
282
|
+
});
|
|
283
|
+
return true;
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
private explainFixed(monic: Monic, value: Rational) {
|
|
287
|
+
const core = this.core;
|
|
288
|
+
const lra = core.lra;
|
|
289
|
+
let dep: Dependency = null;
|
|
290
|
+
const updateDep = (lpVar: number) => {
|
|
291
|
+
dep = mkJoin(dep, lra.getLowerWitness(lpVar));
|
|
292
|
+
dep = mkJoin(dep, lra.getUpperWitness(lpVar));
|
|
293
|
+
return dep;
|
|
294
|
+
};
|
|
295
|
+
if (value.isZero()) {
|
|
296
|
+
for (const lpVar of monic.vars) if (core.varIsFixedToZero(lpVar)) return updateDep(lpVar);
|
|
297
|
+
} else for (const lpVar of monic.vars) if (core.varIsFixed(lpVar)) updateDep(lpVar);
|
|
298
|
+
return dep;
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
// is_linear: the one non-fixed factor, or a factor fixed to zero, unless two are non-fixed.
|
|
302
|
+
private getLinear(monic: Monic) {
|
|
303
|
+
const core = this.core;
|
|
304
|
+
let nonFixed = -1;
|
|
305
|
+
for (const lpVar of monic.vars) {
|
|
306
|
+
if (!core.varIsFixed(lpVar)) {
|
|
307
|
+
if (nonFixed !== -1) return undefined;
|
|
308
|
+
nonFixed = lpVar;
|
|
309
|
+
} else if (core.getLowerBound(lpVar).isZero()) return { nonFixed, fixedToZero: lpVar };
|
|
310
|
+
}
|
|
311
|
+
return { nonFixed, fixedToZero: -1 };
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
// fixed_var_product: from the lower bounds, since a value may lie outside its bounds.
|
|
315
|
+
private getFixedVarProduct(monic: Monic, nonFixed: number) {
|
|
316
|
+
let product = Rational.one;
|
|
317
|
+
for (const lpVar of monic.vars)
|
|
318
|
+
if (lpVar !== nonFixed) product = product.mul(this.core.lra.getLowerBound(lpVar).x);
|
|
319
|
+
return product;
|
|
320
|
+
}
|
|
321
|
+
|
|
322
|
+
// range is an interval that v^p lies in: v's upper bound from it.
|
|
323
|
+
private tightenLpUpperBound(range: DepInterval, lpVar: number, exponent: number) {
|
|
324
|
+
const core = this.core;
|
|
325
|
+
const isImprovingUpper = (candidate: Rational) =>
|
|
326
|
+
!core.hasUpperBound(lpVar) || candidate.compare(core.getUpperBound(lpVar)) < 0;
|
|
327
|
+
let isTightened = false;
|
|
328
|
+
if (!range.isUpperInf) {
|
|
329
|
+
const root = range.upper.root(exponent);
|
|
330
|
+
if (root !== undefined && isImprovingUpper(root)) {
|
|
331
|
+
this.propagateLpBound(lpVar, range.isUpperOpen ? KIND_LT : KIND_LE, root, range.upperDep);
|
|
332
|
+
isTightened = true;
|
|
333
|
+
}
|
|
334
|
+
}
|
|
335
|
+
if (
|
|
336
|
+
exponent % 2 === 0 &&
|
|
337
|
+
!range.isLowerInf &&
|
|
338
|
+
core.hasUpperBound(lpVar) &&
|
|
339
|
+
!core.getUpperBound(lpVar).isPositive() &&
|
|
340
|
+
!range.lower.isNegative()
|
|
341
|
+
) {
|
|
342
|
+
const root = range.lower.root(exponent);
|
|
343
|
+
if (root !== undefined && isImprovingUpper(root.neg())) {
|
|
344
|
+
const dep = mkJoin(range.lowerDep, core.lra.getUpperWitness(lpVar));
|
|
345
|
+
this.propagateLpBound(lpVar, range.isLowerOpen ? KIND_LT : KIND_LE, root.neg(), dep);
|
|
346
|
+
isTightened = true;
|
|
347
|
+
}
|
|
348
|
+
}
|
|
349
|
+
return isTightened;
|
|
350
|
+
}
|
|
351
|
+
|
|
352
|
+
private tightenLpLowerBound(range: DepInterval, lpVar: number, exponent: number) {
|
|
353
|
+
const core = this.core;
|
|
354
|
+
const isImprovingLower = (candidate: Rational) =>
|
|
355
|
+
!core.hasLowerBound(lpVar) || candidate.compare(core.getLowerBound(lpVar)) > 0;
|
|
356
|
+
let isTightened = false;
|
|
357
|
+
if (exponent % 2 === 1) {
|
|
358
|
+
if (!range.isLowerInf) {
|
|
359
|
+
const root = range.lower.root(exponent);
|
|
360
|
+
if (root !== undefined && isImprovingLower(root)) {
|
|
361
|
+
this.propagateLpBound(lpVar, range.isLowerOpen ? KIND_GT : KIND_GE, root, range.lowerDep);
|
|
362
|
+
isTightened = true;
|
|
363
|
+
}
|
|
364
|
+
}
|
|
365
|
+
return isTightened;
|
|
366
|
+
}
|
|
367
|
+
if (!range.isUpperInf && !range.upper.isNegative()) {
|
|
368
|
+
const root = range.upper.root(exponent);
|
|
369
|
+
if (root !== undefined && isImprovingLower(root.neg())) {
|
|
370
|
+
this.propagateLpBound(
|
|
371
|
+
lpVar,
|
|
372
|
+
range.isUpperOpen ? KIND_GT : KIND_GE,
|
|
373
|
+
root.neg(),
|
|
374
|
+
range.upperDep,
|
|
375
|
+
);
|
|
376
|
+
isTightened = true;
|
|
377
|
+
}
|
|
378
|
+
}
|
|
379
|
+
if (
|
|
380
|
+
!range.isLowerInf &&
|
|
381
|
+
core.hasLowerBound(lpVar) &&
|
|
382
|
+
!core.getLowerBound(lpVar).isNegative() &&
|
|
383
|
+
!range.lower.isNegative()
|
|
384
|
+
) {
|
|
385
|
+
const root = range.lower.root(exponent);
|
|
386
|
+
if (root !== undefined && isImprovingLower(root)) {
|
|
387
|
+
const dep = mkJoin(range.lowerDep, core.lra.getLowerWitness(lpVar));
|
|
388
|
+
this.propagateLpBound(lpVar, range.isLowerOpen ? KIND_GT : KIND_GE, root, dep);
|
|
389
|
+
isTightened = true;
|
|
390
|
+
}
|
|
391
|
+
}
|
|
392
|
+
return isTightened;
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
// propagate_lp_bound: a bound on v, integral when v is.
|
|
396
|
+
private propagateLpBound(lpVar: number, kind: ConstraintKind, value: Rational, dep: Dependency) {
|
|
397
|
+
const lra = this.core.lra;
|
|
398
|
+
const update = (updateKind: ConstraintKind, bound: Rational) =>
|
|
399
|
+
lra.updateColumnTypeAndBound(lpVar, updateKind, new Impq(bound), dep);
|
|
400
|
+
if (!this.core.varIsInt(lpVar)) update(kind, value);
|
|
401
|
+
else if (value.isInt()) {
|
|
402
|
+
if (kind === KIND_GT) update(KIND_GE, value.add(Rational.one));
|
|
403
|
+
else if (kind === KIND_LT) update(KIND_LE, value.sub(Rational.one));
|
|
404
|
+
else update(kind, value);
|
|
405
|
+
} else if (kind === KIND_GE || kind === KIND_GT) update(KIND_GE, value.ceil());
|
|
406
|
+
else update(KIND_LE, value.floor());
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
private tightenLpBound(range: DepInterval, lpVar: number, exponent: number) {
|
|
410
|
+
let isPropagated = false;
|
|
411
|
+
if (this.tightenLpUpperBound(range, lpVar, exponent)) isPropagated = true;
|
|
412
|
+
if (this.tightenLpLowerBound(range, lpVar, exponent)) isPropagated = true;
|
|
413
|
+
return isPropagated;
|
|
414
|
+
}
|
|
415
|
+
|
|
416
|
+
tightenLpBounds() {
|
|
417
|
+
let isNewBound = false;
|
|
418
|
+
for (const monic of this.core.emons.monics) if (this.tightenLp(monic)) isNewBound = true;
|
|
419
|
+
return isNewBound;
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
// max_min: a bounded-effort primal simplex walk that maximizes or minimizes a column, keeping
|
|
423
|
+
// integer columns integral, as theory_arith::max_min does.
|
|
424
|
+
|
|
425
|
+
private isSafeGain(gain: Gain) {
|
|
426
|
+
return gain.isUnbounded || new Impq(gain.minGain).compare(gain.maxGain) <= 0;
|
|
427
|
+
}
|
|
428
|
+
|
|
429
|
+
private initGains(column: number, isIncreasing: boolean): Gain {
|
|
430
|
+
const lra = this.core.lra;
|
|
431
|
+
const core = lra.core;
|
|
432
|
+
const gain: Gain = { isUnbounded: true, minGain: Rational.minusOne, maxGain: Impq.zero };
|
|
433
|
+
if (isIncreasing && core.hasUpperBound(column)) {
|
|
434
|
+
gain.isUnbounded = false;
|
|
435
|
+
gain.maxGain = core.upperBounds[column].sub(core.x[column]);
|
|
436
|
+
} else if (!isIncreasing && core.hasLowerBound(column)) {
|
|
437
|
+
gain.isUnbounded = false;
|
|
438
|
+
gain.maxGain = core.x[column].sub(core.lowerBounds[column]);
|
|
439
|
+
}
|
|
440
|
+
if (lra.isInt(column)) gain.minGain = Rational.one;
|
|
441
|
+
return gain;
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
private updateGains(isIncreasing: boolean, basic: number, coeff: Rational, gain: Gain) {
|
|
445
|
+
const lra = this.core.lra;
|
|
446
|
+
const core = lra.core;
|
|
447
|
+
if (!this.isSafeGain(gain)) return false;
|
|
448
|
+
const isDecrementing =
|
|
449
|
+
(isIncreasing && coeff.isPositive()) || (!isIncreasing && coeff.isNegative());
|
|
450
|
+
let isBounded = false;
|
|
451
|
+
let maxIncrease = Impq.zero;
|
|
452
|
+
if (isDecrementing && core.hasLowerBound(basic)) {
|
|
453
|
+
maxIncrease = getAbs(core.x[basic].sub(core.lowerBounds[basic]).div(coeff));
|
|
454
|
+
isBounded = true;
|
|
455
|
+
} else if (!isDecrementing && core.hasUpperBound(basic)) {
|
|
456
|
+
maxIncrease = getAbs(core.upperBounds[basic].sub(core.x[basic]).div(coeff));
|
|
457
|
+
isBounded = true;
|
|
458
|
+
}
|
|
459
|
+
const isBasicInt = lra.isInt(basic);
|
|
460
|
+
const coeffDen = isBasicInt ? Rational.of(coeff.den) : Rational.one;
|
|
461
|
+
if (isBasicInt && !coeffDen.equals(Rational.one)) {
|
|
462
|
+
gain.minGain = gain.minGain.isNegative()
|
|
463
|
+
? coeffDen
|
|
464
|
+
: Rational.of(getLcm(gain.minGain.num, coeffDen.num));
|
|
465
|
+
if (!gain.isUnbounded) gain.maxGain = roundDown(gain.maxGain, gain.minGain);
|
|
466
|
+
}
|
|
467
|
+
if (isBasicInt && !gain.isUnbounded && !gain.maxGain.isInt())
|
|
468
|
+
gain.maxGain = roundDown(new Impq(gain.maxGain.floor()), gain.minGain);
|
|
469
|
+
if (!isBounded) return false;
|
|
470
|
+
if (isBasicInt) maxIncrease = roundDown(new Impq(maxIncrease.floor()), gain.minGain);
|
|
471
|
+
if (gain.isUnbounded) {
|
|
472
|
+
gain.isUnbounded = false;
|
|
473
|
+
gain.maxGain = maxIncrease;
|
|
474
|
+
return true;
|
|
475
|
+
}
|
|
476
|
+
if (gain.maxGain.compare(maxIncrease) > 0) {
|
|
477
|
+
gain.maxGain = maxIncrease;
|
|
478
|
+
return true;
|
|
479
|
+
}
|
|
480
|
+
return false;
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
private pickVarToLeave(column: number, isIncreasing: boolean) {
|
|
484
|
+
const lra = this.core.lra;
|
|
485
|
+
const core = lra.core;
|
|
486
|
+
let leaving = -1;
|
|
487
|
+
let leavingCoeff = Rational.zero;
|
|
488
|
+
const gain = this.initGains(column, isIncreasing);
|
|
489
|
+
if (lra.isInt(column) && !core.x[column].isInt())
|
|
490
|
+
return { isSafe: false, gain, leaving, leavingCoeff };
|
|
491
|
+
for (const cell of core.matrix.columns[column]) {
|
|
492
|
+
const basic = core.basis[cell.row];
|
|
493
|
+
const coeff = core.matrix.getVal(cell);
|
|
494
|
+
if (
|
|
495
|
+
this.updateGains(isIncreasing, basic, coeff, gain) ||
|
|
496
|
+
(leaving === -1 && !gain.isUnbounded)
|
|
497
|
+
) {
|
|
498
|
+
leaving = basic;
|
|
499
|
+
leavingCoeff = coeff;
|
|
500
|
+
}
|
|
501
|
+
}
|
|
502
|
+
return { isSafe: this.isSafeGain(gain), gain, leaving, leavingCoeff };
|
|
503
|
+
}
|
|
504
|
+
|
|
505
|
+
private updateValue(column: number, delta: Impq) {
|
|
506
|
+
if (delta.isZero()) return;
|
|
507
|
+
const lra = this.core.lra;
|
|
508
|
+
lra.setValueForNbasicColumn(column, lra.core.x[column].add(delta));
|
|
509
|
+
}
|
|
510
|
+
|
|
511
|
+
private moveToBound(column: number, isIncreasing: boolean) {
|
|
512
|
+
const lra = this.core.lra;
|
|
513
|
+
const core = lra.core;
|
|
514
|
+
if (lra.isInt(column) && !core.x[column].isInt()) return false;
|
|
515
|
+
const gain = this.initGains(column, isIncreasing);
|
|
516
|
+
for (const cell of core.matrix.columns[column])
|
|
517
|
+
this.updateGains(isIncreasing, core.basis[cell.row], core.matrix.getVal(cell), gain);
|
|
518
|
+
if (!this.isSafeGain(gain) || gain.isUnbounded) return false;
|
|
519
|
+
this.updateValue(column, isIncreasing ? gain.maxGain : gain.maxGain.neg());
|
|
520
|
+
return !gain.maxGain.isZero();
|
|
521
|
+
}
|
|
522
|
+
|
|
523
|
+
private optimize(target: number, isMaximizing: boolean) {
|
|
524
|
+
const lra = this.core.lra;
|
|
525
|
+
const core = lra.core;
|
|
526
|
+
let bestEfforts = 0;
|
|
527
|
+
for (let rounds = 0; bestEfforts < 20 && rounds < 200 && !this.core.isCanceled();) {
|
|
528
|
+
rounds++;
|
|
529
|
+
let entering = -1;
|
|
530
|
+
let leaving = -1;
|
|
531
|
+
let leavingCoeff = Rational.zero;
|
|
532
|
+
let best: Gain = { isUnbounded: true, minGain: Rational.minusOne, maxGain: Impq.zero };
|
|
533
|
+
let isIncreasing = false;
|
|
534
|
+
let hasBound = false;
|
|
535
|
+
const consider = (candidate: number, objectiveCoeff: Rational) => {
|
|
536
|
+
const isCurrentIncreasing = objectiveCoeff.isPositive() ? isMaximizing : !isMaximizing;
|
|
537
|
+
if (
|
|
538
|
+
(isCurrentIncreasing && core.hasUpperBound(candidate)) ||
|
|
539
|
+
(!isCurrentIncreasing && core.hasLowerBound(candidate))
|
|
540
|
+
)
|
|
541
|
+
hasBound = true;
|
|
542
|
+
if (
|
|
543
|
+
isCurrentIncreasing &&
|
|
544
|
+
core.hasUpperBound(candidate) &&
|
|
545
|
+
core.x[candidate].equals(core.upperBounds[candidate])
|
|
546
|
+
)
|
|
547
|
+
return false;
|
|
548
|
+
if (
|
|
549
|
+
!isCurrentIncreasing &&
|
|
550
|
+
core.hasLowerBound(candidate) &&
|
|
551
|
+
core.x[candidate].equals(core.lowerBounds[candidate])
|
|
552
|
+
)
|
|
553
|
+
return false;
|
|
554
|
+
const picked = this.pickVarToLeave(candidate, isCurrentIncreasing);
|
|
555
|
+
if (!picked.isSafe) {
|
|
556
|
+
hasBound = true;
|
|
557
|
+
bestEfforts++;
|
|
558
|
+
return false;
|
|
559
|
+
}
|
|
560
|
+
const select = () => {
|
|
561
|
+
leaving = picked.leaving;
|
|
562
|
+
entering = candidate;
|
|
563
|
+
leavingCoeff = picked.leavingCoeff;
|
|
564
|
+
best = picked.gain;
|
|
565
|
+
isIncreasing = isCurrentIncreasing;
|
|
566
|
+
};
|
|
567
|
+
if (picked.leaving === -1) {
|
|
568
|
+
select();
|
|
569
|
+
return true;
|
|
570
|
+
}
|
|
571
|
+
if (picked.gain.maxGain.compare(best.maxGain) > 0) select();
|
|
572
|
+
else if (picked.gain.maxGain.isZero() && (leaving === -1 || picked.leaving < leaving))
|
|
573
|
+
select();
|
|
574
|
+
return false;
|
|
575
|
+
};
|
|
576
|
+
if (!core.isBase(target)) consider(target, Rational.one);
|
|
577
|
+
else {
|
|
578
|
+
const row = core.matrix.rows[core.heading[target]];
|
|
579
|
+
const targetCoeff = row.find((cell) => cell.column === target)?.coeff ?? Rational.zero;
|
|
580
|
+
for (const cell of row) {
|
|
581
|
+
if (cell.column === target) continue;
|
|
582
|
+
const objectiveCoeff = targetCoeff.isNegative() ? cell.coeff : cell.coeff.neg();
|
|
583
|
+
if (consider(cell.column, objectiveCoeff)) break;
|
|
584
|
+
}
|
|
585
|
+
}
|
|
586
|
+
if (!hasBound && leaving === -1 && entering === -1) return undefined;
|
|
587
|
+
if (entering === -1) {
|
|
588
|
+
if (bestEfforts !== 0 || !core.x[target].y.isZero()) return undefined;
|
|
589
|
+
return core.x[target].x;
|
|
590
|
+
}
|
|
591
|
+
const gain: Gain = best;
|
|
592
|
+
if (gain.minGain.isPositive() && !gain.minGain.equals(Rational.one)) bestEfforts++;
|
|
593
|
+
if (leaving === -1) {
|
|
594
|
+
const hasBlockingBound = isIncreasing
|
|
595
|
+
? core.hasUpperBound(entering)
|
|
596
|
+
: core.hasLowerBound(entering);
|
|
597
|
+
if (!hasBlockingBound || gain.maxGain.isZero()) return undefined;
|
|
598
|
+
this.updateValue(entering, isIncreasing ? gain.maxGain : gain.maxGain.neg());
|
|
599
|
+
continue;
|
|
600
|
+
}
|
|
601
|
+
if (
|
|
602
|
+
core.hasLowerBound(entering) &&
|
|
603
|
+
core.hasUpperBound(entering) &&
|
|
604
|
+
!core.lowerBounds[entering].equals(core.upperBounds[entering]) &&
|
|
605
|
+
core.upperBounds[entering].sub(core.lowerBounds[entering]).equals(gain.maxGain)
|
|
606
|
+
) {
|
|
607
|
+
this.updateValue(entering, isIncreasing ? gain.maxGain : gain.maxGain.neg());
|
|
608
|
+
continue;
|
|
609
|
+
}
|
|
610
|
+
core.pivot(entering, leaving);
|
|
611
|
+
const isLeavingIncreasing = isIncreasing
|
|
612
|
+
? leavingCoeff.isNegative()
|
|
613
|
+
: leavingCoeff.isPositive();
|
|
614
|
+
if (!this.moveToBound(leaving, isLeavingIncreasing)) bestEfforts++;
|
|
615
|
+
}
|
|
616
|
+
return undefined;
|
|
617
|
+
}
|
|
618
|
+
|
|
619
|
+
// mm_dep_from_row: the witnesses of the bounds that bound the column through its row.
|
|
620
|
+
private getDepFromRow(target: number, isMaximizing: boolean) {
|
|
621
|
+
const lra = this.core.lra;
|
|
622
|
+
const core = lra.core;
|
|
623
|
+
if (!core.isBase(target)) return null;
|
|
624
|
+
const row = core.matrix.rows[core.heading[target]];
|
|
625
|
+
const targetCoeff = row.find((cell) => cell.column === target)?.coeff ?? Rational.zero;
|
|
626
|
+
if (targetCoeff.isZero()) return null;
|
|
627
|
+
let dep: Dependency = null;
|
|
628
|
+
for (const cell of row) {
|
|
629
|
+
if (cell.column === target) continue;
|
|
630
|
+
const coeff = cell.coeff.neg().div(targetCoeff);
|
|
631
|
+
if (coeff.isZero()) continue;
|
|
632
|
+
const isUsingUpper = isMaximizing ? coeff.isPositive() : coeff.isNegative();
|
|
633
|
+
if (isUsingUpper) {
|
|
634
|
+
if (!core.hasUpperBound(cell.column)) return null;
|
|
635
|
+
dep = mkJoin(dep, lra.getUpperWitness(cell.column));
|
|
636
|
+
} else {
|
|
637
|
+
if (!core.hasLowerBound(cell.column)) return null;
|
|
638
|
+
dep = mkJoin(dep, lra.getLowerWitness(cell.column));
|
|
639
|
+
}
|
|
640
|
+
}
|
|
641
|
+
return dep;
|
|
642
|
+
}
|
|
643
|
+
|
|
644
|
+
private improveBound(column: number, isLower: boolean) {
|
|
645
|
+
const lra = this.core.lra;
|
|
646
|
+
const core = lra.core;
|
|
647
|
+
if (!lra.isFeasible()) return undefined;
|
|
648
|
+
const bound = this.optimize(column, !isLower);
|
|
649
|
+
if (bound === undefined) return undefined;
|
|
650
|
+
const dep = this.getDepFromRow(column, !isLower);
|
|
651
|
+
if (dep === null) return undefined;
|
|
652
|
+
if (isLower && core.hasLowerBound(column) && bound.compare(core.lowerBounds[column].x) <= 0)
|
|
653
|
+
return undefined;
|
|
654
|
+
if (!isLower && core.hasUpperBound(column) && bound.compare(core.upperBounds[column].x) >= 0)
|
|
655
|
+
return undefined;
|
|
656
|
+
return { bound, dep };
|
|
657
|
+
}
|
|
658
|
+
|
|
659
|
+
// optimize_nl_bounds: tightens the bounds of the variables of monomials by optimizing each over
|
|
660
|
+
// the tableau, then applies them together and makes the tableau feasible again.
|
|
661
|
+
optimizeNlBounds() {
|
|
662
|
+
const core = this.core;
|
|
663
|
+
const lra = core.lra;
|
|
664
|
+
if (!NLA_PARAMS.optimizeBounds || !lra.isFeasible()) return false;
|
|
665
|
+
if (lra.findFeasibleSolution() === LP_INFEASIBLE) {
|
|
666
|
+
core.initToRefine();
|
|
667
|
+
return false;
|
|
668
|
+
}
|
|
669
|
+
const candidates: number[] = [];
|
|
670
|
+
const addCandidate = (lpVar: number) => {
|
|
671
|
+
if (core.activeVarSet.has(lpVar)) return;
|
|
672
|
+
core.activeVarSet.add(lpVar);
|
|
673
|
+
if (!lra.isFixed(lpVar)) candidates.push(lpVar);
|
|
674
|
+
};
|
|
675
|
+
core.activeVarSet.clear();
|
|
676
|
+
for (const monic of core.emons.monics) {
|
|
677
|
+
addCandidate(monic.variable);
|
|
678
|
+
for (const lpVar of monic.vars) addCandidate(lpVar);
|
|
679
|
+
}
|
|
680
|
+
const maxVars = NLA_PARAMS.optimizeBoundsLpMaxVars;
|
|
681
|
+
if (maxVars !== 0 && candidates.length > maxVars) {
|
|
682
|
+
core.initToRefine();
|
|
683
|
+
return false;
|
|
684
|
+
}
|
|
685
|
+
const improvements: ImprovedBound[] = [];
|
|
686
|
+
for (const column of candidates) {
|
|
687
|
+
if (!lra.isFeasible()) break;
|
|
688
|
+
for (const isLower of [true, false]) {
|
|
689
|
+
const improved = this.improveBound(column, isLower);
|
|
690
|
+
if (improved === undefined) continue;
|
|
691
|
+
improvements.push({
|
|
692
|
+
column,
|
|
693
|
+
kind: isLower ? KIND_GE : KIND_LE,
|
|
694
|
+
bound: improved.bound,
|
|
695
|
+
dep: improved.dep,
|
|
696
|
+
});
|
|
697
|
+
}
|
|
698
|
+
}
|
|
699
|
+
for (const improved of improvements)
|
|
700
|
+
lra.updateColumnTypeAndBound(
|
|
701
|
+
improved.column,
|
|
702
|
+
improved.kind,
|
|
703
|
+
new Impq(improved.bound),
|
|
704
|
+
improved.dep,
|
|
705
|
+
);
|
|
706
|
+
lra.findFeasibleSolution();
|
|
707
|
+
core.initToRefine();
|
|
708
|
+
return improvements.length > 0;
|
|
709
|
+
}
|
|
710
|
+
}
|
|
711
|
+
|
|
712
|
+
const getBitSize = (value: Rational) => {
|
|
713
|
+
const magnitude = value.num < 0n ? -value.num : value.num;
|
|
714
|
+
return magnitude === 0n ? 1 : magnitude.toString(2).length;
|
|
715
|
+
};
|