tla-ts 0.0.10-dev.4a2a53c48 → 0.0.10-dev.5ffc55ce5
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/dist/deciders.cjs +35 -35
- package/dist/deciders.js +29 -29
- package/dist/index.d.cts +1 -1
- package/dist/index.d.ts +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove.cjs +25 -25
- package/dist/prove.js +57 -57
- package/dist/run.cjs +26 -28
- package/dist/run.js +42 -44
- package/dist/transfer.cjs +35 -35
- package/dist/transfer.js +28 -28
- package/dist/worker.cjs +1 -1
- package/dist/worker.js +1 -1
- package/package.json +1 -1
- package/src/bags.ts +47 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +143 -61
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +1 -2
- package/src/cli/tlc.ts +13 -8
- package/src/dfid.ts +9 -2
- package/src/environment.ts +18 -0
- package/src/evaluate.ts +9 -3
- package/src/exit-codes.ts +2 -0
- package/src/liveness-checker.ts +45 -4
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/prover/smt/solver/ast.ts +1 -1
- package/src/prover/smt/solver/context.ts +6 -2
- package/src/prover/smt/solver/euf/egraph.ts +1 -1
- package/src/prover/smt/solver/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/goal.ts +2 -0
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- package/src/prover/smt/solver/lp/containers.ts +7 -1
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
- package/src/prover/smt/solver/lp/nex.ts +2 -1
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -1
- package/src/prover/smt/solver/lp/nla-core.ts +26 -6
- package/src/prover/smt/solver/lp/nla-grobner.ts +156 -79
- package/src/prover/smt/solver/lp/nra-solver.ts +138 -95
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -289
- package/src/prover/smt/solver/muz/dl-context.ts +8 -2
- package/src/prover/smt/solver/muz/spacer-context.ts +1 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +194 -89
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +464 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2400 -680
- package/src/prover/smt/solver/nlsat/solver.ts +74 -71
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +40 -17
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-solver.ts +2 -3
- package/src/prover/smt/solver/rlimit.ts +13 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +2 -1
- package/src/prover/smt/solver/seq-derive.ts +3 -6
- package/src/prover/smt/solver/smtlib-parser.ts +10 -10
- package/src/prover/smt/solver/smtlib-script.ts +91 -28
- package/src/prover/smt/solver/tactic.ts +14 -5
- package/src/prover/smt/solver/theory-lra-internalize.ts +8 -0
- package/src/prover/zenon/equality-rules.ts +24 -0
- package/src/prover/zenon/expr.ts +21 -0
- package/src/prover/zenon/index-table.ts +2 -0
- package/src/prover/zenon/rules.ts +2 -1
- package/src/resolve.ts +1 -1
- package/src/runtime.ts +2 -0
- package/src/sany/generator-expressions.ts +6 -13
- package/src/search.ts +40 -11
- package/src/tlc/order.ts +14 -3
- package/src/tlc/tlcext-operators.ts +18 -5
- package/src/tlc/trace-spec.ts +2 -3
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
import { SmtInvariantError } from "../../../../errors";
|
|
2
|
+
import { RandomGen } from "../random-gen";
|
|
2
3
|
import { getGcd, Rational } from "../rational";
|
|
3
|
-
import {
|
|
4
|
+
import type { ResourceLimit } from "../rlimit";
|
|
5
|
+
import { BIG_PRIMES, getExtendedGcd, UpolynomialManager } from "./upolynomial";
|
|
4
6
|
import {
|
|
5
7
|
DEFAULT_FACTOR_PARAMS,
|
|
6
8
|
factorSquareFree,
|
|
@@ -30,6 +32,24 @@ const RATIONAL_OPS: ValueOps<Rational> = {
|
|
|
30
32
|
const getMonomialKey = (vars: readonly number[], degrees: readonly number[]) =>
|
|
31
33
|
vars.map((variable, index) => `${variable}^${degrees[index]}`).join(",");
|
|
32
34
|
|
|
35
|
+
const normalizeZp = (value: bigint, modulus: bigint) => {
|
|
36
|
+
const upper = modulus / 2n;
|
|
37
|
+
const lower = modulus % 2n === 0n ? -upper + 1n : -upper;
|
|
38
|
+
const rest = value % modulus;
|
|
39
|
+
return rest > upper ? rest - modulus : rest < lower ? rest + modulus : rest;
|
|
40
|
+
};
|
|
41
|
+
|
|
42
|
+
const divMpz = (dividend: bigint, divisor: bigint) => {
|
|
43
|
+
const quotient = dividend / divisor;
|
|
44
|
+
if (dividend >= 0n || dividend % divisor === 0n) return quotient;
|
|
45
|
+
return divisor < 0n ? quotient + 1n : quotient - 1n;
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
const modMpz = (value: bigint, modulus: bigint) => {
|
|
49
|
+
const rest = value % modulus;
|
|
50
|
+
return rest < 0n ? rest + (modulus < 0n ? -modulus : modulus) : rest;
|
|
51
|
+
};
|
|
52
|
+
|
|
33
53
|
class Monomial {
|
|
34
54
|
readonly totalDegree: number;
|
|
35
55
|
|
|
@@ -65,6 +85,11 @@ class Monomial {
|
|
|
65
85
|
for (const current of this.vars) if (current < variable) result = current;
|
|
66
86
|
return result;
|
|
67
87
|
}
|
|
88
|
+
|
|
89
|
+
isSquare() {
|
|
90
|
+
for (const degree of this.degrees) if (degree % 2 === 1) return false;
|
|
91
|
+
return true;
|
|
92
|
+
}
|
|
68
93
|
}
|
|
69
94
|
|
|
70
95
|
const lexCompare = (first: Monomial, second: Monomial) => {
|
|
@@ -89,6 +114,45 @@ const lexCompare = (first: Monomial, second: Monomial) => {
|
|
|
89
114
|
return firstIndex < 0 ? -1 : 1;
|
|
90
115
|
};
|
|
91
116
|
|
|
117
|
+
const lexCompare2 = (first: Monomial, second: Monomial, minVar: number) => {
|
|
118
|
+
if (first === second) return 0;
|
|
119
|
+
let firstIndex = first.size - 1;
|
|
120
|
+
let secondIndex = second.size - 1;
|
|
121
|
+
let firstMinVarDegree = 0;
|
|
122
|
+
let secondMinVarDegree = 0;
|
|
123
|
+
while (firstIndex >= 0 && secondIndex >= 0) {
|
|
124
|
+
const firstVar = first.vars[firstIndex];
|
|
125
|
+
const secondVar = second.vars[secondIndex];
|
|
126
|
+
if (firstVar === minVar) {
|
|
127
|
+
firstMinVarDegree = first.degrees[firstIndex];
|
|
128
|
+
firstIndex--;
|
|
129
|
+
if (secondVar === minVar) {
|
|
130
|
+
secondMinVarDegree = second.degrees[secondIndex];
|
|
131
|
+
secondIndex--;
|
|
132
|
+
}
|
|
133
|
+
continue;
|
|
134
|
+
}
|
|
135
|
+
if (secondVar === minVar) {
|
|
136
|
+
secondMinVarDegree = second.degrees[secondIndex];
|
|
137
|
+
secondIndex--;
|
|
138
|
+
continue;
|
|
139
|
+
}
|
|
140
|
+
if (firstVar === secondVar) {
|
|
141
|
+
const firstDegree = first.degrees[firstIndex];
|
|
142
|
+
const secondDegree = second.degrees[secondIndex];
|
|
143
|
+
if (firstDegree === secondDegree) {
|
|
144
|
+
firstIndex--;
|
|
145
|
+
secondIndex--;
|
|
146
|
+
continue;
|
|
147
|
+
}
|
|
148
|
+
return firstDegree < secondDegree ? -1 : 1;
|
|
149
|
+
}
|
|
150
|
+
return firstVar > secondVar ? 1 : -1;
|
|
151
|
+
}
|
|
152
|
+
if (firstIndex === secondIndex) return firstMinVarDegree < secondMinVarDegree ? -1 : 1;
|
|
153
|
+
return firstIndex < 0 ? -1 : 1;
|
|
154
|
+
};
|
|
155
|
+
|
|
92
156
|
const gradedLexCompare = (first: Monomial, second: Monomial) =>
|
|
93
157
|
first.totalDegree === second.totalDegree
|
|
94
158
|
? lexCompare(first, second)
|
|
@@ -105,6 +169,7 @@ const isPoGreater = (first: Monomial, second: Monomial) => {
|
|
|
105
169
|
|
|
106
170
|
export class Polynomial {
|
|
107
171
|
isLexSorted = false;
|
|
172
|
+
refCount = 0;
|
|
108
173
|
|
|
109
174
|
constructor(
|
|
110
175
|
readonly id: number,
|
|
@@ -160,6 +225,13 @@ export class Polynomial {
|
|
|
160
225
|
return maxPos;
|
|
161
226
|
}
|
|
162
227
|
|
|
228
|
+
getGradedLexMinPos() {
|
|
229
|
+
let minPos = 0;
|
|
230
|
+
for (let index = 1; index < this.ms.length; index++)
|
|
231
|
+
if (gradedLexCompare(this.ms[index], this.ms[minPos]) < 0) minPos = index;
|
|
232
|
+
return minPos;
|
|
233
|
+
}
|
|
234
|
+
|
|
163
235
|
toString() {
|
|
164
236
|
if (this.ms.length === 0) return "0";
|
|
165
237
|
return this.ms
|
|
@@ -175,6 +247,112 @@ export class Polynomial {
|
|
|
175
247
|
}
|
|
176
248
|
}
|
|
177
249
|
|
|
250
|
+
export class PolynomialRef {
|
|
251
|
+
private value: Polynomial | null = null;
|
|
252
|
+
|
|
253
|
+
constructor(private readonly pm: PolynomialManager) {}
|
|
254
|
+
|
|
255
|
+
get() {
|
|
256
|
+
const value = this.value;
|
|
257
|
+
if (value === null) throw new SmtInvariantError("polynomial reference is null");
|
|
258
|
+
return value;
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
getOrNull() {
|
|
262
|
+
return this.value;
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
set(polynomial: Polynomial) {
|
|
266
|
+
this.pm.incRef(polynomial);
|
|
267
|
+
if (this.value !== null) this.pm.decRef(this.value);
|
|
268
|
+
this.value = polynomial;
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
copy(other: PolynomialRef) {
|
|
272
|
+
if (this.value === other.value) return;
|
|
273
|
+
if (this.value !== null) this.pm.decRef(this.value);
|
|
274
|
+
this.value = other.value;
|
|
275
|
+
if (this.value !== null) this.pm.incRef(this.value);
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
move(other: PolynomialRef) {
|
|
279
|
+
if (this === other) return;
|
|
280
|
+
if (this.value !== null) this.pm.decRef(this.value);
|
|
281
|
+
this.value = other.value;
|
|
282
|
+
other.value = null;
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
swap(other: PolynomialRef) {
|
|
286
|
+
const value = this.value;
|
|
287
|
+
this.value = other.value;
|
|
288
|
+
other.value = value;
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
reset() {
|
|
292
|
+
if (this.value !== null) this.pm.decRef(this.value);
|
|
293
|
+
this.value = null;
|
|
294
|
+
}
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
export class PolynomialRefVector {
|
|
298
|
+
readonly items: Polynomial[] = [];
|
|
299
|
+
|
|
300
|
+
constructor(private readonly pm: PolynomialManager) {}
|
|
301
|
+
|
|
302
|
+
get size() {
|
|
303
|
+
return this.items.length;
|
|
304
|
+
}
|
|
305
|
+
|
|
306
|
+
get(index: number) {
|
|
307
|
+
return this.items[index];
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
push(polynomial: Polynomial) {
|
|
311
|
+
this.pm.incRef(polynomial);
|
|
312
|
+
this.items.push(polynomial);
|
|
313
|
+
}
|
|
314
|
+
|
|
315
|
+
set(index: number, polynomial: Polynomial) {
|
|
316
|
+
this.pm.incRef(polynomial);
|
|
317
|
+
this.pm.decRef(this.items[index]);
|
|
318
|
+
this.items[index] = polynomial;
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
append(other: PolynomialRefVector) {
|
|
322
|
+
for (const polynomial of other.items) this.push(polynomial);
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
shrink(size: number) {
|
|
326
|
+
for (let index = size; index < this.items.length; index++) this.pm.decRef(this.items[index]);
|
|
327
|
+
this.items.length = size;
|
|
328
|
+
}
|
|
329
|
+
|
|
330
|
+
reset() {
|
|
331
|
+
this.shrink(0);
|
|
332
|
+
}
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
export class Factors {
|
|
336
|
+
constant = 1n;
|
|
337
|
+
readonly factors: Polynomial[] = [];
|
|
338
|
+
readonly degrees: number[] = [];
|
|
339
|
+
|
|
340
|
+
constructor(private readonly pm: PolynomialManager) {}
|
|
341
|
+
|
|
342
|
+
push(polynomial: Polynomial, degree: number) {
|
|
343
|
+
this.factors.push(polynomial);
|
|
344
|
+
this.degrees.push(degree);
|
|
345
|
+
this.pm.incRef(polynomial);
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
reset() {
|
|
349
|
+
for (const factor of this.factors) this.pm.decRef(factor);
|
|
350
|
+
this.factors.length = 0;
|
|
351
|
+
this.degrees.length = 0;
|
|
352
|
+
this.constant = 1n;
|
|
353
|
+
}
|
|
354
|
+
}
|
|
355
|
+
|
|
178
356
|
class SomBuffer {
|
|
179
357
|
as: bigint[] = [];
|
|
180
358
|
ms: Monomial[] = [];
|
|
@@ -190,52 +368,69 @@ class SomBuffer {
|
|
|
190
368
|
|
|
191
369
|
addTerm(coeff: bigint, monomial: Monomial) {
|
|
192
370
|
if (coeff === 0n) return;
|
|
371
|
+
const modulus = this.manager.modulus;
|
|
193
372
|
const position = this.positions.get(monomial.id);
|
|
194
373
|
if (position === undefined) {
|
|
195
374
|
this.positions.set(monomial.id, this.ms.length);
|
|
196
375
|
this.ms.push(monomial);
|
|
197
|
-
this.as.push(coeff);
|
|
376
|
+
this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
|
|
198
377
|
return;
|
|
199
378
|
}
|
|
200
|
-
this.as[position]
|
|
379
|
+
const sum = this.as[position] + coeff;
|
|
380
|
+
this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
|
|
201
381
|
}
|
|
202
382
|
|
|
203
383
|
add(polynomial: Polynomial) {
|
|
384
|
+
const modulus = this.manager.modulus;
|
|
204
385
|
for (let index = 0; index < polynomial.size; index++) {
|
|
205
386
|
const monomial = polynomial.ms[index];
|
|
206
387
|
const position = this.positions.get(monomial.id);
|
|
207
388
|
if (position === undefined) {
|
|
208
389
|
this.positions.set(monomial.id, this.ms.length);
|
|
209
390
|
this.ms.push(monomial);
|
|
210
|
-
|
|
211
|
-
|
|
391
|
+
const coeff = polynomial.as[index];
|
|
392
|
+
this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
|
|
393
|
+
continue;
|
|
394
|
+
}
|
|
395
|
+
const sum = this.as[position] + polynomial.as[index];
|
|
396
|
+
this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
|
|
212
397
|
}
|
|
213
398
|
}
|
|
214
399
|
|
|
215
400
|
addmul(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
|
|
216
401
|
if (coeff === 0n) return;
|
|
402
|
+
const modulus = this.manager.modulus;
|
|
217
403
|
for (let index = 0; index < polynomial.size; index++) {
|
|
218
404
|
const product = this.manager.mulMonomials(monomial, polynomial.ms[index]);
|
|
219
405
|
const position = this.positions.get(product.id);
|
|
220
406
|
if (position === undefined) {
|
|
221
407
|
this.positions.set(product.id, this.ms.length);
|
|
222
408
|
this.ms.push(product);
|
|
223
|
-
|
|
224
|
-
|
|
409
|
+
const value = coeff * polynomial.as[index];
|
|
410
|
+
this.as.push(modulus === null ? value : normalizeZp(value, modulus));
|
|
411
|
+
continue;
|
|
412
|
+
}
|
|
413
|
+
const sum = this.as[position] + coeff * polynomial.as[index];
|
|
414
|
+
this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
|
|
225
415
|
}
|
|
226
416
|
}
|
|
227
417
|
|
|
228
418
|
// Like Z3, zero entries of the other buffer are added too, which keeps their monomials' positions.
|
|
229
419
|
addmulBuffer(coeff: bigint, monomial: Monomial, buffer: SomBuffer) {
|
|
230
420
|
if (coeff === 0n) return;
|
|
421
|
+
const modulus = this.manager.modulus;
|
|
231
422
|
for (let index = 0; index < buffer.ms.length; index++) {
|
|
232
423
|
const product = this.manager.mulMonomials(monomial, buffer.ms[index]);
|
|
233
424
|
const position = this.positions.get(product.id);
|
|
234
425
|
if (position === undefined) {
|
|
235
426
|
this.positions.set(product.id, this.ms.length);
|
|
236
427
|
this.ms.push(product);
|
|
237
|
-
|
|
238
|
-
|
|
428
|
+
const value = coeff * buffer.as[index];
|
|
429
|
+
this.as.push(modulus === null ? value : normalizeZp(value, modulus));
|
|
430
|
+
continue;
|
|
431
|
+
}
|
|
432
|
+
const sum = this.as[position] + coeff * buffer.as[index];
|
|
433
|
+
this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
|
|
239
434
|
}
|
|
240
435
|
}
|
|
241
436
|
|
|
@@ -257,8 +452,8 @@ class SomBuffer {
|
|
|
257
452
|
ms.push(this.ms[index]);
|
|
258
453
|
}
|
|
259
454
|
this.reset();
|
|
260
|
-
|
|
261
|
-
return this.manager.mkPolynomialCore(
|
|
455
|
+
if (isNormalized) this.manager.normalizeNumerals(as);
|
|
456
|
+
return this.manager.mkPolynomialCore(as, ms);
|
|
262
457
|
}
|
|
263
458
|
}
|
|
264
459
|
|
|
@@ -268,20 +463,38 @@ class CheapSomBuffer {
|
|
|
268
463
|
|
|
269
464
|
constructor(private manager: PolynomialManager) {}
|
|
270
465
|
|
|
271
|
-
|
|
466
|
+
addReset(coeff: bigint, monomial: Monomial) {
|
|
272
467
|
if (coeff === 0n) return;
|
|
273
468
|
this.as.push(coeff);
|
|
274
469
|
this.ms.push(monomial);
|
|
275
470
|
}
|
|
276
471
|
|
|
472
|
+
add(coeff: bigint, monomial: Monomial) {
|
|
473
|
+
if (coeff === 0n) return;
|
|
474
|
+
const modulus = this.manager.modulus;
|
|
475
|
+
this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
|
|
476
|
+
this.ms.push(monomial);
|
|
477
|
+
}
|
|
478
|
+
|
|
277
479
|
addmul(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
|
|
278
480
|
if (coeff === 0n) return;
|
|
481
|
+
const modulus = this.manager.modulus;
|
|
279
482
|
for (let index = 0; index < polynomial.size; index++) {
|
|
280
|
-
|
|
483
|
+
const value = coeff * polynomial.as[index];
|
|
484
|
+
this.as.push(modulus === null ? value : normalizeZp(value, modulus));
|
|
281
485
|
this.ms.push(this.manager.mulMonomials(monomial, polynomial.ms[index]));
|
|
282
486
|
}
|
|
283
487
|
}
|
|
284
488
|
|
|
489
|
+
normalize() {
|
|
490
|
+
this.manager.normalizeNumerals(this.as);
|
|
491
|
+
}
|
|
492
|
+
|
|
493
|
+
reset() {
|
|
494
|
+
this.as = [];
|
|
495
|
+
this.ms = [];
|
|
496
|
+
}
|
|
497
|
+
|
|
285
498
|
mk() {
|
|
286
499
|
const result = this.manager.mkPolynomialCore(this.as, this.ms);
|
|
287
500
|
this.as = [];
|
|
@@ -290,27 +503,238 @@ class CheapSomBuffer {
|
|
|
290
503
|
}
|
|
291
504
|
}
|
|
292
505
|
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
506
|
+
class NewtonInterpolator {
|
|
507
|
+
readonly inputs: bigint[] = [];
|
|
508
|
+
private invs: bigint[] = [0n];
|
|
509
|
+
private vs: PolynomialRefVector;
|
|
510
|
+
|
|
511
|
+
constructor(private readonly pm: PolynomialManager) {
|
|
512
|
+
this.vs = new PolynomialRefVector(pm);
|
|
513
|
+
}
|
|
514
|
+
|
|
515
|
+
reset() {
|
|
516
|
+
this.inputs.length = 0;
|
|
517
|
+
this.invs.length = 1;
|
|
518
|
+
this.vs.reset();
|
|
519
|
+
}
|
|
520
|
+
|
|
521
|
+
add(input: bigint, output: Polynomial) {
|
|
522
|
+
const pm = this.pm;
|
|
523
|
+
const size = this.inputs.length;
|
|
524
|
+
if (size === 0) {
|
|
525
|
+
this.inputs.push(input);
|
|
526
|
+
this.vs.push(output);
|
|
527
|
+
return;
|
|
528
|
+
}
|
|
529
|
+
const k = size;
|
|
530
|
+
let product = pm.subNumeral(input, this.inputs[0]);
|
|
531
|
+
for (let index = 1; index <= k - 1; index++)
|
|
532
|
+
product = pm.mulNumeral(product, pm.subNumeral(input, this.inputs[index]));
|
|
533
|
+
product = pm.invNumeral(product);
|
|
534
|
+
this.inputs.push(input);
|
|
535
|
+
this.invs.push(product);
|
|
536
|
+
const temp = new PolynomialRef(pm);
|
|
537
|
+
const auxPoly = new PolynomialRef(pm);
|
|
538
|
+
temp.set(this.vs.get(k - 1));
|
|
539
|
+
for (let j = k - 2; j >= 0; j--) {
|
|
540
|
+
const aux = pm.subNumeral(input, this.inputs[j]);
|
|
541
|
+
auxPoly.set(pm.mulConst(aux, temp.get()));
|
|
542
|
+
temp.set(pm.add(auxPoly.get(), this.vs.get(j)));
|
|
543
|
+
}
|
|
544
|
+
auxPoly.set(pm.sub(output, temp.get()));
|
|
545
|
+
auxPoly.set(pm.mulConst(this.invs[size], auxPoly.get()));
|
|
546
|
+
this.vs.push(auxPoly.get());
|
|
547
|
+
auxPoly.reset();
|
|
548
|
+
temp.reset();
|
|
549
|
+
}
|
|
550
|
+
|
|
551
|
+
mk(x: number, r: PolynomialRef) {
|
|
552
|
+
const pm = this.pm;
|
|
553
|
+
const u = new PolynomialRef(pm);
|
|
554
|
+
const auxPoly = new PolynomialRef(pm);
|
|
555
|
+
const d = this.inputs.length - 1;
|
|
556
|
+
u.set(this.vs.get(d));
|
|
557
|
+
for (let k = d - 1; k >= 0; k--) {
|
|
558
|
+
const c = pm.negNumeral(this.inputs[k]);
|
|
559
|
+
auxPoly.set(pm.mkLinear([1n], [x], c));
|
|
560
|
+
auxPoly.set(pm.mul(u.get(), auxPoly.get()));
|
|
561
|
+
u.set(pm.add(auxPoly.get(), this.vs.get(k)));
|
|
562
|
+
}
|
|
563
|
+
r.copy(u);
|
|
564
|
+
auxPoly.reset();
|
|
565
|
+
u.reset();
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
|
|
569
|
+
interface SkeletonEntry {
|
|
570
|
+
monomial: Monomial;
|
|
571
|
+
firstPowerIndex: number;
|
|
572
|
+
numPowers: number;
|
|
573
|
+
}
|
|
574
|
+
|
|
575
|
+
class Skeleton {
|
|
576
|
+
readonly entries: SkeletonEntry[] = [];
|
|
577
|
+
readonly powers: number[] = [];
|
|
578
|
+
readonly origMonomials: Monomial[] = [];
|
|
579
|
+
maxPowers = 0;
|
|
580
|
+
|
|
581
|
+
constructor(pm: PolynomialManager, polynomial: Polynomial, x: number) {
|
|
582
|
+
const ms = [...polynomial.ms].sort((first, second) => lexCompare2(first, second, x));
|
|
583
|
+
let previous: Monomial | null = null;
|
|
584
|
+
for (const origMonomial of ms) {
|
|
585
|
+
const k = origMonomial.degreeOf(x);
|
|
586
|
+
const monomial = k > 0 ? pm.divX(origMonomial, x) : origMonomial;
|
|
587
|
+
if (monomial === previous) {
|
|
588
|
+
const entry = this.entries[this.entries.length - 1];
|
|
589
|
+
entry.numPowers++;
|
|
590
|
+
if (entry.numPowers > this.maxPowers) this.maxPowers = entry.numPowers;
|
|
591
|
+
} else {
|
|
592
|
+
previous = monomial;
|
|
593
|
+
this.entries.push({ monomial, firstPowerIndex: this.powers.length, numPowers: 1 });
|
|
594
|
+
if (this.maxPowers === 0) this.maxPowers = 1;
|
|
595
|
+
}
|
|
596
|
+
this.origMonomials.push(origMonomial);
|
|
597
|
+
this.powers.push(k);
|
|
598
|
+
}
|
|
599
|
+
}
|
|
600
|
+
|
|
601
|
+
getEntryIndex(monomial: Monomial) {
|
|
602
|
+
for (let index = 0; index < this.entries.length; index++)
|
|
603
|
+
if (this.entries[index].monomial === monomial) return index;
|
|
604
|
+
return -1;
|
|
605
|
+
}
|
|
606
|
+
}
|
|
607
|
+
|
|
608
|
+
const solveLinearEquations = (
|
|
609
|
+
pm: PolynomialManager,
|
|
610
|
+
rows: bigint[][],
|
|
611
|
+
b: bigint[],
|
|
612
|
+
xs: bigint[],
|
|
613
|
+
) => {
|
|
614
|
+
const n = rows.length;
|
|
615
|
+
for (let k = 0; k < n; k++) {
|
|
616
|
+
let i = k;
|
|
617
|
+
for (; i < n; i++) if (rows[i][k] !== 0n) break;
|
|
618
|
+
if (i === n) return false;
|
|
619
|
+
const row = rows[k];
|
|
620
|
+
rows[k] = rows[i];
|
|
621
|
+
rows[i] = row;
|
|
622
|
+
const rowK = rows[k];
|
|
623
|
+
const pivot = rowK[k];
|
|
624
|
+
for (let column = k + 1; column < n; column++)
|
|
625
|
+
rowK[column] = pm.divNumeral(rowK[column], pivot);
|
|
626
|
+
b[k] = pm.divNumeral(b[k], pivot);
|
|
627
|
+
rowK[k] = pm.normalizeNumeral(1n);
|
|
628
|
+
for (let other = k + 1; other < n; other++) {
|
|
629
|
+
const rowI = rows[other];
|
|
630
|
+
const factor = rowI[k];
|
|
631
|
+
for (let column = k + 1; column < n; column++)
|
|
632
|
+
rowI[column] = pm.normalizeNumeral(rowI[column] - factor * rowK[column]);
|
|
633
|
+
b[other] = pm.normalizeNumeral(b[other] - factor * b[k]);
|
|
634
|
+
rowI[k] = 0n;
|
|
635
|
+
}
|
|
636
|
+
}
|
|
637
|
+
for (let k = n; k-- > 0;) {
|
|
638
|
+
xs[k] = b[k];
|
|
639
|
+
for (let other = k; other-- > 0;) {
|
|
640
|
+
b[other] = pm.normalizeNumeral(b[other] - rows[other][k] * b[k]);
|
|
641
|
+
rows[other][k] = 0n;
|
|
642
|
+
}
|
|
643
|
+
}
|
|
644
|
+
return true;
|
|
645
|
+
};
|
|
646
|
+
|
|
647
|
+
class SparseInterpolator {
|
|
648
|
+
private inputs: bigint[] = [];
|
|
649
|
+
private outputs: bigint[] = [];
|
|
650
|
+
|
|
651
|
+
constructor(
|
|
652
|
+
private readonly pm: PolynomialManager,
|
|
653
|
+
skeleton: Skeleton | null,
|
|
654
|
+
) {
|
|
655
|
+
if (skeleton !== null)
|
|
656
|
+
for (const entry of skeleton.entries)
|
|
657
|
+
for (let index = 0; index < entry.numPowers; index++) this.outputs.push(0n);
|
|
658
|
+
}
|
|
659
|
+
|
|
660
|
+
reset() {
|
|
661
|
+
this.inputs.length = 0;
|
|
662
|
+
}
|
|
663
|
+
|
|
664
|
+
isReady(skeleton: Skeleton) {
|
|
665
|
+
return this.inputs.length === skeleton.maxPowers;
|
|
666
|
+
}
|
|
667
|
+
|
|
668
|
+
add(skeleton: Skeleton, input: bigint, q: Polynomial) {
|
|
669
|
+
const inputIndex = this.inputs.length;
|
|
670
|
+
this.inputs.push(this.pm.normalizeNumeral(input));
|
|
671
|
+
for (let index = 0; index < q.size; index++) {
|
|
672
|
+
const entryIndex = skeleton.getEntryIndex(q.ms[index]);
|
|
673
|
+
if (entryIndex === -1) return false;
|
|
674
|
+
const entry = skeleton.entries[entryIndex];
|
|
675
|
+
if (inputIndex >= entry.numPowers) continue;
|
|
676
|
+
this.outputs[entry.firstPowerIndex + inputIndex] = this.pm.normalizeNumeral(q.as[index]);
|
|
677
|
+
}
|
|
678
|
+
return true;
|
|
679
|
+
}
|
|
680
|
+
|
|
681
|
+
mk(skeleton: Skeleton, r: PolynomialRef) {
|
|
682
|
+
const pm = this.pm;
|
|
683
|
+
const as: bigint[] = [];
|
|
684
|
+
const ms: Monomial[] = [];
|
|
685
|
+
let rows: bigint[][] = [];
|
|
686
|
+
let b: bigint[] = [];
|
|
687
|
+
for (const entry of skeleton.entries) {
|
|
688
|
+
const numPowers = entry.numPowers;
|
|
689
|
+
if (rows.length !== numPowers) {
|
|
690
|
+
rows = Array.from({ length: numPowers }, () => Array.from({ length: numPowers }, () => 0n));
|
|
691
|
+
b = Array.from({ length: numPowers }, () => 0n);
|
|
692
|
+
}
|
|
693
|
+
const newAs = Array.from({ length: numPowers }, () => 0n);
|
|
694
|
+
for (let index = 0; index < numPowers; index++) {
|
|
695
|
+
const input = this.inputs[index];
|
|
696
|
+
for (let j = 0; j < numPowers; j++)
|
|
697
|
+
rows[index][j] = pm.powerNumeral(input, skeleton.powers[entry.firstPowerIndex + j]);
|
|
698
|
+
b[index] = this.outputs[entry.firstPowerIndex + index];
|
|
699
|
+
}
|
|
700
|
+
if (!solveLinearEquations(pm, rows, b, newAs)) return false;
|
|
701
|
+
for (let index = 0; index < numPowers; index++) {
|
|
702
|
+
if (newAs[index] === 0n) continue;
|
|
703
|
+
as.push(newAs[index]);
|
|
704
|
+
ms.push(skeleton.origMonomials[entry.firstPowerIndex + index]);
|
|
705
|
+
}
|
|
706
|
+
}
|
|
707
|
+
r.set(pm.mkPolynomial(as, ms));
|
|
708
|
+
return true;
|
|
709
|
+
}
|
|
297
710
|
}
|
|
298
711
|
|
|
299
712
|
export class PolynomialManager {
|
|
300
713
|
private monomials = new Map<string, Monomial>();
|
|
301
714
|
private nextPolynomialId = 0;
|
|
715
|
+
private freePolynomialIds: number[] = [];
|
|
716
|
+
private polynomials: (Polynomial | null)[] = [];
|
|
717
|
+
modulus: bigint | null = null;
|
|
302
718
|
readonly unit: Monomial;
|
|
303
719
|
readonly zero: Polynomial;
|
|
304
720
|
readonly one: Polynomial;
|
|
305
|
-
private um
|
|
721
|
+
private um: UpolynomialManager;
|
|
306
722
|
private som = new SomBuffer(this);
|
|
307
723
|
private som2 = new SomBuffer(this);
|
|
308
724
|
private cheap = new CheapSomBuffer(this);
|
|
309
|
-
|
|
310
|
-
|
|
725
|
+
private cheap2 = new CheapSomBuffer(this);
|
|
726
|
+
private random = new RandomGen(0);
|
|
727
|
+
private mgcdInterpolators: NewtonInterpolator[] = [];
|
|
728
|
+
private mgcdSkeletons: (Skeleton | null)[] = [];
|
|
729
|
+
private iccpZpXBuffers: SomBuffer[] = [];
|
|
730
|
+
|
|
731
|
+
constructor(readonly limit: ResourceLimit) {
|
|
732
|
+
this.um = new UpolynomialManager(limit);
|
|
311
733
|
this.unit = this.mkMonomial([], []);
|
|
312
734
|
this.zero = this.mkPolynomialCore([], []);
|
|
313
|
-
this.
|
|
735
|
+
this.incRef(this.zero);
|
|
736
|
+
this.one = this.mkConstCore(1n);
|
|
737
|
+
this.incRef(this.one);
|
|
314
738
|
}
|
|
315
739
|
|
|
316
740
|
mkMonomial(vars: readonly number[], degrees: readonly number[]) {
|
|
@@ -322,7 +746,7 @@ export class PolynomialManager {
|
|
|
322
746
|
return monomial;
|
|
323
747
|
}
|
|
324
748
|
|
|
325
|
-
rename(permutation: readonly number[]
|
|
749
|
+
rename(permutation: readonly number[]) {
|
|
326
750
|
const monomials = new Map<string, Monomial>();
|
|
327
751
|
for (const monomial of this.monomials.values()) {
|
|
328
752
|
const order = monomial.vars
|
|
@@ -336,7 +760,8 @@ export class PolynomialManager {
|
|
|
336
760
|
monomials.set(getMonomialKey(monomial.vars, monomial.degrees), monomial);
|
|
337
761
|
}
|
|
338
762
|
this.monomials = monomials;
|
|
339
|
-
for (const polynomial of polynomials)
|
|
763
|
+
for (const polynomial of this.polynomials)
|
|
764
|
+
if (polynomial !== null) polynomial.makeFirstMaximal();
|
|
340
765
|
}
|
|
341
766
|
|
|
342
767
|
mkPower(variable: number, power: number) {
|
|
@@ -401,22 +826,118 @@ export class PolynomialManager {
|
|
|
401
826
|
return this.mkMonomial(vars, degrees);
|
|
402
827
|
}
|
|
403
828
|
|
|
404
|
-
|
|
829
|
+
divX(monomial: Monomial, variable: number) {
|
|
405
830
|
return this.divXk(monomial, variable, monomial.degreeOf(variable));
|
|
406
831
|
}
|
|
407
832
|
|
|
833
|
+
private sqrtMonomial(monomial: Monomial) {
|
|
834
|
+
return this.mkMonomial(
|
|
835
|
+
monomial.vars,
|
|
836
|
+
monomial.degrees.map((degree) => degree / 2),
|
|
837
|
+
);
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
normalizeNumeral(value: bigint) {
|
|
841
|
+
const modulus = this.modulus;
|
|
842
|
+
return modulus === null ? value : normalizeZp(value, modulus);
|
|
843
|
+
}
|
|
844
|
+
|
|
845
|
+
subNumeral(first: bigint, second: bigint) {
|
|
846
|
+
return this.normalizeNumeral(first - second);
|
|
847
|
+
}
|
|
848
|
+
|
|
849
|
+
mulNumeral(first: bigint, second: bigint) {
|
|
850
|
+
return this.normalizeNumeral(first * second);
|
|
851
|
+
}
|
|
852
|
+
|
|
853
|
+
negNumeral(value: bigint) {
|
|
854
|
+
return this.normalizeNumeral(-value);
|
|
855
|
+
}
|
|
856
|
+
|
|
857
|
+
invNumeral(value: bigint) {
|
|
858
|
+
const modulus = this.modulus;
|
|
859
|
+
if (modulus === null) throw new SmtInvariantError("inverse over Z");
|
|
860
|
+
return normalizeZp(getExtendedGcd(normalizeZp(value, modulus), modulus).x, modulus);
|
|
861
|
+
}
|
|
862
|
+
|
|
863
|
+
divNumeral(dividend: bigint, divisor: bigint) {
|
|
864
|
+
return this.modulus === null
|
|
865
|
+
? divMpz(dividend, divisor)
|
|
866
|
+
: this.mulNumeral(dividend, this.invNumeral(divisor));
|
|
867
|
+
}
|
|
868
|
+
|
|
869
|
+
powerNumeral(base: bigint, exponent: number) {
|
|
870
|
+
if (exponent === 1) return this.normalizeNumeral(base);
|
|
871
|
+
if (exponent === 0) return this.normalizeNumeral(1n);
|
|
872
|
+
let mask = 1;
|
|
873
|
+
let power = this.normalizeNumeral(base);
|
|
874
|
+
let result = this.normalizeNumeral(1n);
|
|
875
|
+
while (mask <= exponent) {
|
|
876
|
+
if ((mask & exponent) !== 0) result = this.mulNumeral(result, power);
|
|
877
|
+
power = this.mulNumeral(power, power);
|
|
878
|
+
mask <<= 1;
|
|
879
|
+
}
|
|
880
|
+
return result;
|
|
881
|
+
}
|
|
882
|
+
|
|
883
|
+
private dividesNumeral(divisor: bigint, dividend: bigint) {
|
|
884
|
+
if (this.modulus !== null && divisor !== 0n) return true;
|
|
885
|
+
return divisor === 0n ? dividend === 0n : dividend % divisor === 0n;
|
|
886
|
+
}
|
|
887
|
+
|
|
888
|
+
private gcdNumerals(as: readonly bigint[]) {
|
|
889
|
+
let result = 0n;
|
|
890
|
+
for (const coeff of as) result = getGcd(result, coeff);
|
|
891
|
+
return result;
|
|
892
|
+
}
|
|
893
|
+
|
|
894
|
+
normalizeNumerals(as: bigint[]) {
|
|
895
|
+
if (as.length === 0) return;
|
|
896
|
+
const g = this.gcdNumerals(as);
|
|
897
|
+
if (g === 1n) return;
|
|
898
|
+
for (let index = 0; index < as.length; index++) as[index] = this.divNumeral(as[index], g);
|
|
899
|
+
}
|
|
900
|
+
|
|
901
|
+
setZp(prime: bigint) {
|
|
902
|
+
this.modulus = prime;
|
|
903
|
+
}
|
|
904
|
+
|
|
905
|
+
setZ() {
|
|
906
|
+
this.modulus = null;
|
|
907
|
+
}
|
|
908
|
+
|
|
408
909
|
mkPolynomialCore(as: bigint[], ms: Monomial[]) {
|
|
409
|
-
|
|
910
|
+
const id = this.freePolynomialIds.pop() ?? this.nextPolynomialId++;
|
|
911
|
+
const polynomial = new Polynomial(id, as, ms);
|
|
912
|
+
this.polynomials[id] = polynomial;
|
|
913
|
+
return polynomial;
|
|
914
|
+
}
|
|
915
|
+
|
|
916
|
+
incRef(polynomial: Polynomial) {
|
|
917
|
+
polynomial.refCount++;
|
|
918
|
+
}
|
|
919
|
+
|
|
920
|
+
decRef(polynomial: Polynomial) {
|
|
921
|
+
if (--polynomial.refCount === 0) this.del(polynomial);
|
|
922
|
+
}
|
|
923
|
+
|
|
924
|
+
private del(polynomial: Polynomial) {
|
|
925
|
+
this.polynomials[polynomial.id] = null;
|
|
926
|
+
this.freePolynomialIds.push(polynomial.id);
|
|
927
|
+
}
|
|
928
|
+
|
|
929
|
+
private mkConstCore(value: bigint) {
|
|
930
|
+
return this.mkPolynomialCore([value], [this.unit]);
|
|
410
931
|
}
|
|
411
932
|
|
|
412
933
|
mkConst(value: bigint) {
|
|
413
934
|
if (value === 0n) return this.zero;
|
|
414
935
|
if (value === 1n) return this.one;
|
|
415
|
-
return this.
|
|
936
|
+
return this.mkConstCore(value);
|
|
416
937
|
}
|
|
417
938
|
|
|
418
939
|
mkVar(variable: number, degree = 1) {
|
|
419
|
-
return this.mkPolynomialCore([1n], [this.
|
|
940
|
+
return this.mkPolynomialCore([1n], [this.mkPower(variable, degree)]);
|
|
420
941
|
}
|
|
421
942
|
|
|
422
943
|
mkPolynomial(as: readonly bigint[], ms: readonly Monomial[]) {
|
|
@@ -425,6 +946,17 @@ export class PolynomialManager {
|
|
|
425
946
|
return this.som.mk();
|
|
426
947
|
}
|
|
427
948
|
|
|
949
|
+
private mkUnivariate(variable: number, coeffs: readonly bigint[]) {
|
|
950
|
+
for (let power = coeffs.length - 1; power >= 0; power--)
|
|
951
|
+
this.cheap.addReset(coeffs[power], this.mkPower(variable, power));
|
|
952
|
+
return this.cheap.mk();
|
|
953
|
+
}
|
|
954
|
+
|
|
955
|
+
toPolynomial(coeffs: readonly bigint[], variable: number) {
|
|
956
|
+
if (coeffs.length === 0) return this.zero;
|
|
957
|
+
return this.mkUnivariate(variable, coeffs);
|
|
958
|
+
}
|
|
959
|
+
|
|
428
960
|
mkLinear(as: readonly bigint[], vars: readonly number[], constant: bigint) {
|
|
429
961
|
const coeffs: bigint[] = [];
|
|
430
962
|
const ms: Monomial[] = [];
|
|
@@ -502,29 +1034,47 @@ export class PolynomialManager {
|
|
|
502
1034
|
return key;
|
|
503
1035
|
}
|
|
504
1036
|
|
|
505
|
-
|
|
1037
|
+
addmulTerms(
|
|
1038
|
+
firstCoeff: bigint,
|
|
1039
|
+
firstMonomial: Monomial,
|
|
1040
|
+
first: Polynomial,
|
|
1041
|
+
secondCoeff: bigint,
|
|
1042
|
+
secondMonomial: Monomial,
|
|
1043
|
+
second: Polynomial,
|
|
1044
|
+
) {
|
|
506
1045
|
this.som.reset();
|
|
507
|
-
this.som.addmul(firstCoeff,
|
|
508
|
-
this.som.addmul(secondCoeff,
|
|
1046
|
+
this.som.addmul(firstCoeff, firstMonomial, first);
|
|
1047
|
+
this.som.addmul(secondCoeff, secondMonomial, second);
|
|
509
1048
|
return this.som.mk();
|
|
510
1049
|
}
|
|
511
1050
|
|
|
1051
|
+
addmul(first: Polynomial, secondCoeff: bigint, second: Polynomial) {
|
|
1052
|
+
return this.addmulTerms(1n, this.unit, first, secondCoeff, this.unit, second);
|
|
1053
|
+
}
|
|
1054
|
+
|
|
512
1055
|
add(first: Polynomial, second: Polynomial) {
|
|
513
|
-
return this.
|
|
1056
|
+
return this.addmulTerms(1n, this.unit, first, 1n, this.unit, second);
|
|
514
1057
|
}
|
|
515
1058
|
|
|
516
1059
|
sub(first: Polynomial, second: Polynomial) {
|
|
517
|
-
return this.
|
|
1060
|
+
return this.addmulTerms(1n, this.unit, first, this.normalizeNumeral(-1n), this.unit, second);
|
|
518
1061
|
}
|
|
519
1062
|
|
|
520
|
-
|
|
521
|
-
if (first.size === 0 || second.size === 0) return this.
|
|
1063
|
+
muladd(first: Polynomial, second: Polynomial, constant: bigint) {
|
|
1064
|
+
if (first.size === 0 || second.size === 0) return this.mkConst(constant);
|
|
522
1065
|
this.som.reset();
|
|
523
|
-
for (let index = 0; index < first.size; index++)
|
|
1066
|
+
for (let index = 0; index < first.size; index++) {
|
|
1067
|
+
this.limit.checkpoint();
|
|
524
1068
|
this.som.addmul(first.as[index], first.ms[index], second);
|
|
1069
|
+
}
|
|
1070
|
+
this.som.addTerm(constant, this.unit);
|
|
525
1071
|
return this.som.mk();
|
|
526
1072
|
}
|
|
527
1073
|
|
|
1074
|
+
mul(first: Polynomial, second: Polynomial) {
|
|
1075
|
+
return this.muladd(first, second, 0n);
|
|
1076
|
+
}
|
|
1077
|
+
|
|
528
1078
|
mulTerm(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
|
|
529
1079
|
if (coeff === 0n) return this.zero;
|
|
530
1080
|
if (coeff === 1n && monomial === this.unit) return polynomial;
|
|
@@ -536,17 +1086,26 @@ export class PolynomialManager {
|
|
|
536
1086
|
return this.mulTerm(coeff, this.unit, polynomial);
|
|
537
1087
|
}
|
|
538
1088
|
|
|
539
|
-
|
|
1089
|
+
private mulScaled(coeff: bigint, first: Polynomial, second: Polynomial) {
|
|
1090
|
+
if (coeff === 0n || first.size === 0 || second.size === 0) return this.zero;
|
|
1091
|
+
this.som.reset();
|
|
1092
|
+
for (let index = 0; index < first.size; index++) {
|
|
1093
|
+
this.limit.checkpoint();
|
|
1094
|
+
this.som.addmul(this.mulNumeral(coeff, first.as[index]), first.ms[index], second);
|
|
1095
|
+
}
|
|
1096
|
+
return this.som.mk();
|
|
1097
|
+
}
|
|
1098
|
+
|
|
1099
|
+
private divConst(polynomial: Polynomial, divisor: bigint) {
|
|
540
1100
|
for (let index = 0; index < polynomial.size; index++)
|
|
541
|
-
this.cheap.add(
|
|
1101
|
+
this.cheap.add(this.divNumeral(polynomial.as[index], divisor), polynomial.ms[index]);
|
|
542
1102
|
return this.cheap.mk();
|
|
543
1103
|
}
|
|
544
1104
|
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
return result;
|
|
1105
|
+
neg(polynomial: Polynomial) {
|
|
1106
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
1107
|
+
this.cheap.add(this.negNumeral(polynomial.as[index]), polynomial.ms[index]);
|
|
1108
|
+
return this.cheap.mk();
|
|
550
1109
|
}
|
|
551
1110
|
|
|
552
1111
|
coeff(polynomial: Polynomial, variable: number, power: number) {
|
|
@@ -558,6 +1117,17 @@ export class PolynomialManager {
|
|
|
558
1117
|
return this.cheap.mk();
|
|
559
1118
|
}
|
|
560
1119
|
|
|
1120
|
+
coeffWithReduct(polynomial: Polynomial, variable: number, power: number, reduct: PolynomialRef) {
|
|
1121
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
1122
|
+
const monomial = polynomial.ms[index];
|
|
1123
|
+
if (monomial.degreeOf(variable) === power)
|
|
1124
|
+
this.cheap.add(polynomial.as[index], this.divX(monomial, variable));
|
|
1125
|
+
else this.cheap2.add(polynomial.as[index], monomial);
|
|
1126
|
+
}
|
|
1127
|
+
reduct.set(this.cheap2.mk());
|
|
1128
|
+
return this.cheap.mk();
|
|
1129
|
+
}
|
|
1130
|
+
|
|
561
1131
|
getConstCoeff(polynomial: Polynomial, variable: number, power: number) {
|
|
562
1132
|
let result = 0n;
|
|
563
1133
|
for (let index = 0; index < polynomial.size; index++) {
|
|
@@ -569,6 +1139,17 @@ export class PolynomialManager {
|
|
|
569
1139
|
return result;
|
|
570
1140
|
}
|
|
571
1141
|
|
|
1142
|
+
isNonzeroConstCoeff(polynomial: Polynomial, variable: number, power: number) {
|
|
1143
|
+
const coeff = this.getConstCoeff(polynomial, variable, power);
|
|
1144
|
+
return coeff !== null && coeff !== 0n;
|
|
1145
|
+
}
|
|
1146
|
+
|
|
1147
|
+
private getUnivCoeff(polynomial: Polynomial, power: number) {
|
|
1148
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
1149
|
+
if (polynomial.ms[index].totalDegree === power) return polynomial.as[index];
|
|
1150
|
+
return 0n;
|
|
1151
|
+
}
|
|
1152
|
+
|
|
572
1153
|
lc(polynomial: Polynomial, variable: number) {
|
|
573
1154
|
return this.coeff(polynomial, variable, this.degree(polynomial, variable));
|
|
574
1155
|
}
|
|
@@ -578,7 +1159,10 @@ export class PolynomialManager {
|
|
|
578
1159
|
const monomial = polynomial.ms[index];
|
|
579
1160
|
const degree = monomial.degreeOf(variable);
|
|
580
1161
|
if (degree > 0)
|
|
581
|
-
this.cheap.
|
|
1162
|
+
this.cheap.addReset(
|
|
1163
|
+
this.mulNumeral(polynomial.as[index], BigInt(degree)),
|
|
1164
|
+
this.divXk(monomial, variable, 1),
|
|
1165
|
+
);
|
|
582
1166
|
}
|
|
583
1167
|
return this.cheap.mk();
|
|
584
1168
|
}
|
|
@@ -599,24 +1183,43 @@ export class PolynomialManager {
|
|
|
599
1183
|
return result;
|
|
600
1184
|
}
|
|
601
1185
|
|
|
602
|
-
private icWithContent(polynomial: Polynomial
|
|
603
|
-
if (polynomial.size === 0)
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
if (
|
|
1186
|
+
private icWithContent(polynomial: Polynomial, c: PolynomialRef) {
|
|
1187
|
+
if (polynomial.size === 0) {
|
|
1188
|
+
c.set(polynomial);
|
|
1189
|
+
return 0n;
|
|
1190
|
+
}
|
|
1191
|
+
if (this.isConst(polynomial)) {
|
|
1192
|
+
c.set(this.one);
|
|
1193
|
+
return polynomial.as[0];
|
|
1194
|
+
}
|
|
1195
|
+
const content = this.gcdNumerals(polynomial.as);
|
|
1196
|
+
if (content === 1n) {
|
|
1197
|
+
c.set(polynomial);
|
|
1198
|
+
return content;
|
|
1199
|
+
}
|
|
1200
|
+
this.cheap.reset();
|
|
608
1201
|
for (let index = 0; index < polynomial.size; index++)
|
|
609
|
-
this.cheap.
|
|
610
|
-
|
|
1202
|
+
this.cheap.addReset(this.divNumeral(polynomial.as[index], content), polynomial.ms[index]);
|
|
1203
|
+
c.set(this.cheap.mk());
|
|
1204
|
+
return content;
|
|
611
1205
|
}
|
|
612
1206
|
|
|
613
|
-
iccp(polynomial: Polynomial, variable: number
|
|
614
|
-
if (polynomial.size === 0)
|
|
615
|
-
|
|
1207
|
+
iccp(polynomial: Polynomial, variable: number, c: PolynomialRef, pp: PolynomialRef) {
|
|
1208
|
+
if (polynomial.size === 0) {
|
|
1209
|
+
c.set(this.one);
|
|
1210
|
+
pp.set(polynomial);
|
|
1211
|
+
return 0n;
|
|
1212
|
+
}
|
|
1213
|
+
if (this.isConst(polynomial)) {
|
|
1214
|
+
c.set(this.one);
|
|
1215
|
+
pp.set(this.one);
|
|
1216
|
+
return polynomial.as[0];
|
|
1217
|
+
}
|
|
616
1218
|
const degree = this.degree(polynomial, variable);
|
|
617
1219
|
if (degree === 0) {
|
|
618
|
-
const
|
|
619
|
-
|
|
1220
|
+
const integer = this.icWithContent(polynomial, c);
|
|
1221
|
+
pp.set(this.one);
|
|
1222
|
+
return integer;
|
|
620
1223
|
}
|
|
621
1224
|
const filter = Array.from({ length: degree + 1 }, () => 0);
|
|
622
1225
|
const powers: number[] = [];
|
|
@@ -625,160 +1228,598 @@ export class PolynomialManager {
|
|
|
625
1228
|
if (filter[power] === 0) powers.push(power);
|
|
626
1229
|
filter[power] += monomial.size === (power > 0 ? 1 : 0) ? 1 : 2;
|
|
627
1230
|
}
|
|
628
|
-
const
|
|
629
|
-
|
|
630
|
-
|
|
1231
|
+
for (const power of powers)
|
|
1232
|
+
if (filter[power] === 1) {
|
|
1233
|
+
const integer = this.icWithContent(polynomial, pp);
|
|
1234
|
+
c.set(this.one);
|
|
1235
|
+
return integer;
|
|
1236
|
+
}
|
|
1237
|
+
const integer = this.icWithContent(polynomial, pp);
|
|
1238
|
+
const ci = new PolynomialRef(this);
|
|
1239
|
+
c.set(this.coeff(pp.get(), variable, powers[0]));
|
|
631
1240
|
for (let index = 1; index < powers.length; index++) {
|
|
632
|
-
|
|
633
|
-
|
|
1241
|
+
ci.set(this.coeff(pp.get(), variable, powers[index]));
|
|
1242
|
+
this.gcd(c.get(), ci.get(), c);
|
|
1243
|
+
if (this.isConst(c.get())) {
|
|
1244
|
+
c.set(this.one);
|
|
1245
|
+
ci.reset();
|
|
1246
|
+
return integer;
|
|
1247
|
+
}
|
|
634
1248
|
}
|
|
635
|
-
|
|
636
|
-
|
|
1249
|
+
c.set(this.flipSignIfLmNeg(c.get()));
|
|
1250
|
+
pp.set(this.exactDiv(pp.get(), c.get()));
|
|
1251
|
+
ci.reset();
|
|
1252
|
+
return integer;
|
|
637
1253
|
}
|
|
638
1254
|
|
|
639
1255
|
pp(polynomial: Polynomial, variable: number) {
|
|
640
|
-
|
|
1256
|
+
const c = new PolynomialRef(this);
|
|
1257
|
+
const result = new PolynomialRef(this);
|
|
1258
|
+
this.iccp(polynomial, variable, c, result);
|
|
1259
|
+
c.reset();
|
|
1260
|
+
return result;
|
|
641
1261
|
}
|
|
642
1262
|
|
|
643
|
-
|
|
644
|
-
|
|
645
|
-
const
|
|
646
|
-
|
|
647
|
-
const
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
return this.mul(this.mulConst(integer, squareFreeContent), squareFreePrimitive);
|
|
1263
|
+
isPrimitive(polynomial: Polynomial, variable: number) {
|
|
1264
|
+
const c = new PolynomialRef(this);
|
|
1265
|
+
const pp = new PolynomialRef(this);
|
|
1266
|
+
this.iccp(polynomial, variable, c, pp);
|
|
1267
|
+
const result = this.eq(polynomial, pp.get());
|
|
1268
|
+
pp.reset();
|
|
1269
|
+
c.reset();
|
|
1270
|
+
return result;
|
|
652
1271
|
}
|
|
653
1272
|
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
const
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
const
|
|
1273
|
+
private gcdPrs(first: Polynomial, second: Polynomial, variable: number, r: PolynomialRef) {
|
|
1274
|
+
const isSwapped = this.degree(first, variable) < this.degree(second, variable);
|
|
1275
|
+
const u = isSwapped ? second : first;
|
|
1276
|
+
const v = isSwapped ? first : second;
|
|
1277
|
+
const cU = new PolynomialRef(this);
|
|
1278
|
+
const cV = new PolynomialRef(this);
|
|
1279
|
+
const ppU = new PolynomialRef(this);
|
|
1280
|
+
const ppV = new PolynomialRef(this);
|
|
1281
|
+
const dR = new PolynomialRef(this);
|
|
1282
|
+
const g = new PolynomialRef(this);
|
|
1283
|
+
const h = new PolynomialRef(this);
|
|
1284
|
+
const rem = new PolynomialRef(this);
|
|
1285
|
+
const newH = new PolynomialRef(this);
|
|
1286
|
+
const release = () => {
|
|
1287
|
+
newH.reset();
|
|
1288
|
+
rem.reset();
|
|
1289
|
+
h.reset();
|
|
1290
|
+
g.reset();
|
|
1291
|
+
dR.reset();
|
|
1292
|
+
ppV.reset();
|
|
1293
|
+
ppU.reset();
|
|
1294
|
+
cV.reset();
|
|
1295
|
+
cU.reset();
|
|
1296
|
+
};
|
|
1297
|
+
const iU = this.iccp(u, variable, cU, ppU);
|
|
1298
|
+
const iV = this.iccp(v, variable, cV, ppV);
|
|
1299
|
+
this.gcd(cU.get(), cV.get(), dR);
|
|
1300
|
+
const dA = getGcd(iU, iV);
|
|
1301
|
+
g.set(this.one);
|
|
1302
|
+
h.set(this.one);
|
|
679
1303
|
while (true) {
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
1304
|
+
this.limit.checkpoint();
|
|
1305
|
+
const delta = this.degree(ppU.get(), variable) - this.degree(ppV.get(), variable);
|
|
1306
|
+
this.exactPseudoRemainder(ppU.get(), ppV.get(), variable, rem);
|
|
1307
|
+
if (this.isZero(rem.get())) {
|
|
1308
|
+
ppV.set(this.flipSignIfLmNeg(ppV.get()));
|
|
1309
|
+
r.move(this.pp(ppV.get(), variable));
|
|
1310
|
+
r.set(this.mulScaled(dA, dR.get(), r.get()));
|
|
1311
|
+
release();
|
|
1312
|
+
return;
|
|
684
1313
|
}
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
1314
|
+
if (this.isConst(rem.get())) {
|
|
1315
|
+
r.set(this.mulConst(dA, dR.get()));
|
|
1316
|
+
release();
|
|
1317
|
+
return;
|
|
1318
|
+
}
|
|
1319
|
+
ppU.copy(ppV);
|
|
1320
|
+
ppV.set(this.exactDiv(rem.get(), g.get()));
|
|
1321
|
+
for (let index = 0; index < delta; index++) ppV.set(this.exactDiv(ppV.get(), h.get()));
|
|
1322
|
+
g.set(this.lc(ppU.get(), variable));
|
|
1323
|
+
newH.set(this.one);
|
|
1324
|
+
for (let index = 0; index < delta; index++) newH.set(this.mul(newH.get(), g.get()));
|
|
1325
|
+
if (delta > 1)
|
|
1326
|
+
for (let index = 0; index < delta - 1; index++)
|
|
1327
|
+
newH.set(this.exactDiv(newH.get(), h.get()));
|
|
1328
|
+
h.copy(newH);
|
|
690
1329
|
}
|
|
691
1330
|
}
|
|
692
1331
|
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
variable
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
1332
|
+
private gcdContent(u: Polynomial, variable: number, v: Polynomial, r: PolynomialRef) {
|
|
1333
|
+
const cU = new PolynomialRef(this);
|
|
1334
|
+
const ppU = new PolynomialRef(this);
|
|
1335
|
+
const iU = this.iccp(u, variable, cU, ppU);
|
|
1336
|
+
cU.set(this.mulConst(iU, cU.get()));
|
|
1337
|
+
this.gcd(cU.get(), v, r);
|
|
1338
|
+
ppU.reset();
|
|
1339
|
+
cU.reset();
|
|
700
1340
|
}
|
|
701
1341
|
|
|
702
|
-
|
|
703
|
-
|
|
1342
|
+
private euclidGcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
|
|
1343
|
+
if (this.isZero(u)) {
|
|
1344
|
+
r.set(v);
|
|
1345
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1346
|
+
return;
|
|
1347
|
+
}
|
|
1348
|
+
if (this.isZero(v)) {
|
|
1349
|
+
r.set(u);
|
|
1350
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1351
|
+
return;
|
|
1352
|
+
}
|
|
1353
|
+
if (u === v) {
|
|
1354
|
+
r.set(u);
|
|
1355
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1356
|
+
return;
|
|
1357
|
+
}
|
|
1358
|
+
if (this.isConst(u) || this.isConst(v)) {
|
|
1359
|
+
const iV = this.getIc(v);
|
|
1360
|
+
const iU = this.getIc(u);
|
|
1361
|
+
r.set(this.mkConst(getGcd(iV, iU)));
|
|
1362
|
+
return;
|
|
1363
|
+
}
|
|
1364
|
+
this.gcdPrs(u, v, this.maxVar(u), r);
|
|
704
1365
|
}
|
|
705
1366
|
|
|
706
|
-
private
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
1367
|
+
private craCombineImages(
|
|
1368
|
+
c1: Polynomial,
|
|
1369
|
+
b1: bigint,
|
|
1370
|
+
c2: Polynomial,
|
|
1371
|
+
b2: bigint,
|
|
1372
|
+
r: PolynomialRef,
|
|
712
1373
|
) {
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
let
|
|
728
|
-
let
|
|
729
|
-
let steps = 0;
|
|
1374
|
+
c1.lexSort();
|
|
1375
|
+
c2.lexSort();
|
|
1376
|
+
const inverses = getExtendedGcd(b1, b2);
|
|
1377
|
+
const inv1 = modMpz(inverses.x, b2);
|
|
1378
|
+
const inv2 = modMpz(inverses.y, b1);
|
|
1379
|
+
const a1 = this.mulNumeral(b2, inv2);
|
|
1380
|
+
const a2 = this.mulNumeral(b1, inv1);
|
|
1381
|
+
const newBound = this.mulNumeral(b1, b2);
|
|
1382
|
+
const upper = divMpz(newBound, 2n);
|
|
1383
|
+
const add = (first: bigint, second: bigint, monomial: Monomial) => {
|
|
1384
|
+
const tmp3 = this.normalizeNumeral(this.mulNumeral(first, a1) + this.mulNumeral(second, a2));
|
|
1385
|
+
const value = modMpz(tmp3, newBound);
|
|
1386
|
+
this.cheap.add(value > upper ? this.subNumeral(value, newBound) : value, monomial);
|
|
1387
|
+
};
|
|
1388
|
+
let i1 = 0;
|
|
1389
|
+
let i2 = 0;
|
|
730
1390
|
while (true) {
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
if (isExact && steps < exactSteps) {
|
|
735
|
-
const power = this.pw(lcB, exactSteps - steps);
|
|
736
|
-
if (isQuotient) quotient = this.mul(power, quotient);
|
|
737
|
-
remainder = this.mul(power, remainder);
|
|
738
|
-
}
|
|
739
|
-
return { quotient, remainder, steps };
|
|
1391
|
+
if (i1 === c1.size) {
|
|
1392
|
+
for (; i2 < c2.size; i2++) add(0n, c2.as[i2], c2.ms[i2]);
|
|
1393
|
+
break;
|
|
740
1394
|
}
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
const monomial = remainder.ms[index];
|
|
745
|
-
const coeff = remainder.as[index];
|
|
746
|
-
if (monomial.degreeOf(variable) === degR) {
|
|
747
|
-
const shifted = this.divXk(monomial, variable, degB);
|
|
748
|
-
if (isQuotient) this.som2.addTerm(coeff, shifted);
|
|
749
|
-
this.som.addmul(-coeff, shifted, reductB);
|
|
750
|
-
} else this.som.addmul(coeff, monomial, lcB);
|
|
1395
|
+
if (i2 === c2.size) {
|
|
1396
|
+
for (; i1 < c1.size; i1++) add(c1.as[i1], 0n, c1.ms[i1]);
|
|
1397
|
+
break;
|
|
751
1398
|
}
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
1399
|
+
const m1 = c1.ms[i1];
|
|
1400
|
+
const m2 = c2.ms[i2];
|
|
1401
|
+
const s = lexCompare(m1, m2);
|
|
1402
|
+
if (s === 0) {
|
|
1403
|
+
add(c1.as[i1], c2.as[i2], m1);
|
|
1404
|
+
i1++;
|
|
1405
|
+
i2++;
|
|
1406
|
+
} else if (s > 0) {
|
|
1407
|
+
add(c1.as[i1], 0n, m1);
|
|
1408
|
+
i1++;
|
|
1409
|
+
} else {
|
|
1410
|
+
add(0n, c2.as[i2], m2);
|
|
1411
|
+
i2++;
|
|
757
1412
|
}
|
|
758
|
-
steps++;
|
|
759
1413
|
}
|
|
1414
|
+
r.set(this.cheap.mk());
|
|
1415
|
+
return newBound;
|
|
1416
|
+
}
|
|
1417
|
+
|
|
1418
|
+
private uniModGcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
|
|
1419
|
+
const x = this.maxVar(u);
|
|
1420
|
+
const ppU = new PolynomialRef(this);
|
|
1421
|
+
const ppV = new PolynomialRef(this);
|
|
1422
|
+
const cU = this.icWithContent(u, ppU);
|
|
1423
|
+
const cV = this.icWithContent(v, ppV);
|
|
1424
|
+
const dA = getGcd(cU, cV);
|
|
1425
|
+
const dU = this.degree(ppU.get(), x);
|
|
1426
|
+
const dV = this.degree(ppV.get(), x);
|
|
1427
|
+
const lcU = this.getUnivCoeff(ppU.get(), dU);
|
|
1428
|
+
const lcV = this.getUnivCoeff(ppV.get(), dV);
|
|
1429
|
+
const lcG = getGcd(lcU, lcV);
|
|
1430
|
+
const uZp = new PolynomialRef(this);
|
|
1431
|
+
const vZp = new PolynomialRef(this);
|
|
1432
|
+
const cStar = new PolynomialRef(this);
|
|
1433
|
+
let bound = 0n;
|
|
1434
|
+
const q = new PolynomialRef(this);
|
|
1435
|
+
const candidate = new PolynomialRef(this);
|
|
1436
|
+
const release = () => {
|
|
1437
|
+
candidate.reset();
|
|
1438
|
+
q.reset();
|
|
1439
|
+
cStar.reset();
|
|
1440
|
+
vZp.reset();
|
|
1441
|
+
uZp.reset();
|
|
1442
|
+
ppV.reset();
|
|
1443
|
+
ppU.reset();
|
|
1444
|
+
};
|
|
1445
|
+
for (const prime of BIG_PRIMES) {
|
|
1446
|
+
const savedModulus = this.modulus;
|
|
1447
|
+
this.setZp(prime);
|
|
1448
|
+
uZp.set(this.normalize(ppU.get()));
|
|
1449
|
+
vZp.set(this.normalize(ppV.get()));
|
|
1450
|
+
const isBadPrime = this.degree(uZp.get(), x) < dU || this.degree(vZp.get(), x) < dV;
|
|
1451
|
+
if (!isBadPrime) {
|
|
1452
|
+
this.euclidGcd(uZp.get(), vZp.get(), q);
|
|
1453
|
+
q.set(this.mkGlexMonic(q.get()));
|
|
1454
|
+
q.set(this.mulConst(this.normalizeNumeral(lcG), q.get()));
|
|
1455
|
+
}
|
|
1456
|
+
this.modulus = savedModulus;
|
|
1457
|
+
if (isBadPrime) continue;
|
|
1458
|
+
if (this.isConst(q.get())) {
|
|
1459
|
+
// Deviation from Z3: when d_a is 1 and q is a constant other than 1, uni_mod_gcd returns q
|
|
1460
|
+
// (polynomial.cpp:4170), so gcd(2x - 3, 2x - 1) is 2 there. This returns 1 and frees q.
|
|
1461
|
+
r.set(dA === 1n && q.get().as[0] === 1n ? q.get() : this.mkConst(dA));
|
|
1462
|
+
release();
|
|
1463
|
+
return;
|
|
1464
|
+
}
|
|
1465
|
+
if (cStar.getOrNull() === null) {
|
|
1466
|
+
cStar.copy(q);
|
|
1467
|
+
bound = prime;
|
|
1468
|
+
} else if (this.degree(q.get(), x) < this.degree(cStar.get(), x)) {
|
|
1469
|
+
cStar.copy(q);
|
|
1470
|
+
bound = prime;
|
|
1471
|
+
} else bound = this.craCombineImages(q.get(), prime, cStar.get(), bound, cStar);
|
|
1472
|
+
candidate.move(this.pp(cStar.get(), x));
|
|
1473
|
+
const lcCandidate = this.getUnivCoeff(candidate.get(), this.degree(candidate.get(), x));
|
|
1474
|
+
if (
|
|
1475
|
+
this.dividesNumeral(lcCandidate, lcG) &&
|
|
1476
|
+
this.divides(candidate.get(), ppU.get()) &&
|
|
1477
|
+
this.divides(candidate.get(), ppV.get())
|
|
1478
|
+
) {
|
|
1479
|
+
r.set(this.mulConst(dA, candidate.get()));
|
|
1480
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1481
|
+
release();
|
|
1482
|
+
return;
|
|
1483
|
+
}
|
|
1484
|
+
}
|
|
1485
|
+
this.gcdPrs(u, v, x, r);
|
|
1486
|
+
release();
|
|
1487
|
+
}
|
|
1488
|
+
|
|
1489
|
+
private iccpZpX(polynomial: Polynomial, x: number, c: PolynomialRef, pp: PolynomialRef): bigint {
|
|
1490
|
+
if (polynomial.size === 0) {
|
|
1491
|
+
c.set(this.one);
|
|
1492
|
+
pp.set(polynomial);
|
|
1493
|
+
return 0n;
|
|
1494
|
+
}
|
|
1495
|
+
if (this.isConst(polynomial)) {
|
|
1496
|
+
c.set(this.one);
|
|
1497
|
+
pp.set(this.one);
|
|
1498
|
+
return polynomial.as[0];
|
|
1499
|
+
}
|
|
1500
|
+
const degree = this.degree(polynomial, x);
|
|
1501
|
+
if (degree === 0) {
|
|
1502
|
+
const ci = this.icWithContent(polynomial, pp);
|
|
1503
|
+
c.set(this.one);
|
|
1504
|
+
return ci;
|
|
1505
|
+
}
|
|
1506
|
+
const marks = new Map<number, number>();
|
|
1507
|
+
const noXMonomials: Monomial[] = [];
|
|
1508
|
+
let minDegree = Infinity;
|
|
1509
|
+
for (const monomial of polynomial.ms) {
|
|
1510
|
+
const k = monomial.degreeOf(x);
|
|
1511
|
+
if (k === 0 && !marks.has(monomial.id)) {
|
|
1512
|
+
noXMonomials.push(monomial);
|
|
1513
|
+
marks.set(monomial.id, 1);
|
|
1514
|
+
}
|
|
1515
|
+
if (k < minDegree) minDegree = k;
|
|
1516
|
+
}
|
|
1517
|
+
if (minDegree > 0) {
|
|
1518
|
+
const xmin = new PolynomialRef(this);
|
|
1519
|
+
const newP = new PolynomialRef(this);
|
|
1520
|
+
xmin.set(this.mkVar(x, minDegree));
|
|
1521
|
+
newP.set(this.exactDiv(polynomial, xmin.get()));
|
|
1522
|
+
const ci = this.iccpZpX(newP.get(), x, c, pp);
|
|
1523
|
+
c.set(this.mul(xmin.get(), c.get()));
|
|
1524
|
+
newP.reset();
|
|
1525
|
+
xmin.reset();
|
|
1526
|
+
return ci;
|
|
1527
|
+
}
|
|
1528
|
+
const numMarked = noXMonomials.length;
|
|
1529
|
+
let numUnmarked = 0;
|
|
1530
|
+
for (const monomial of polynomial.ms) {
|
|
1531
|
+
if (monomial.degreeOf(x) === 0) continue;
|
|
1532
|
+
const reduced = this.divX(monomial, x);
|
|
1533
|
+
if (marks.get(reduced.id) === 1) {
|
|
1534
|
+
numUnmarked++;
|
|
1535
|
+
marks.delete(reduced.id);
|
|
1536
|
+
}
|
|
1537
|
+
}
|
|
1538
|
+
if (numUnmarked < numMarked) {
|
|
1539
|
+
const ci = this.icWithContent(polynomial, pp);
|
|
1540
|
+
c.set(this.one);
|
|
1541
|
+
return ci;
|
|
1542
|
+
}
|
|
1543
|
+
const ci = this.icWithContent(polynomial, pp);
|
|
1544
|
+
marks.clear();
|
|
1545
|
+
noXMonomials.length = 0;
|
|
1546
|
+
const buffers = this.iccpZpXBuffers;
|
|
1547
|
+
const ppValue = pp.get();
|
|
1548
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
1549
|
+
let monomial = ppValue.ms[index];
|
|
1550
|
+
const k = monomial.degreeOf(x);
|
|
1551
|
+
if (k !== 0) monomial = this.divX(monomial, x);
|
|
1552
|
+
let position = marks.get(monomial.id);
|
|
1553
|
+
if (position === undefined) {
|
|
1554
|
+
position = noXMonomials.length;
|
|
1555
|
+
noXMonomials.push(monomial);
|
|
1556
|
+
marks.set(monomial.id, position);
|
|
1557
|
+
}
|
|
1558
|
+
while (buffers.length <= position) buffers.push(new SomBuffer(this));
|
|
1559
|
+
buffers[position].addTerm(ppValue.as[index], this.mkPower(x, k));
|
|
1560
|
+
}
|
|
1561
|
+
const numMonomials = noXMonomials.length;
|
|
1562
|
+
const g = new PolynomialRef(this);
|
|
1563
|
+
const newG = new PolynomialRef(this);
|
|
1564
|
+
g.set(buffers[0].mk());
|
|
1565
|
+
for (let index = 1; index < numMonomials; index++) {
|
|
1566
|
+
const a = new PolynomialRef(this);
|
|
1567
|
+
a.set(buffers[index].mk());
|
|
1568
|
+
this.euclidGcd(g.get(), a.get(), newG);
|
|
1569
|
+
g.copy(newG);
|
|
1570
|
+
const isDone = this.isConst(g.get());
|
|
1571
|
+
a.reset();
|
|
1572
|
+
if (isDone) break;
|
|
1573
|
+
}
|
|
1574
|
+
if (!this.isConst(g.get())) {
|
|
1575
|
+
c.copy(g);
|
|
1576
|
+
pp.set(this.exactDiv(pp.get(), c.get()));
|
|
1577
|
+
} else c.set(this.one);
|
|
1578
|
+
for (let index = 0; index < numMonomials; index++) buffers[index].reset();
|
|
1579
|
+
newG.reset();
|
|
1580
|
+
g.reset();
|
|
1581
|
+
return ci;
|
|
1582
|
+
}
|
|
1583
|
+
|
|
1584
|
+
private lcGlexZpX(polynomial: Polynomial, x: number) {
|
|
1585
|
+
this.som.reset();
|
|
1586
|
+
let maxMonomial: Monomial | null = null;
|
|
1587
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
1588
|
+
let monomial = polynomial.ms[index];
|
|
1589
|
+
const k = monomial.degreeOf(x);
|
|
1590
|
+
if (k !== 0) monomial = this.divX(monomial, x);
|
|
1591
|
+
if (maxMonomial === null || gradedLexCompare(monomial, maxMonomial) > 0) {
|
|
1592
|
+
this.som.reset();
|
|
1593
|
+
maxMonomial = monomial;
|
|
1594
|
+
this.som.addTerm(polynomial.as[index], this.mkPower(x, k));
|
|
1595
|
+
} else if (maxMonomial === monomial)
|
|
1596
|
+
this.som.addTerm(polynomial.as[index], this.mkPower(x, k));
|
|
1597
|
+
}
|
|
1598
|
+
return this.som.mk();
|
|
1599
|
+
}
|
|
1600
|
+
|
|
1601
|
+
private primitiveZpX(polynomial: Polynomial, x: number, pp: PolynomialRef) {
|
|
1602
|
+
const c = new PolynomialRef(this);
|
|
1603
|
+
this.iccpZpX(polynomial, x, c, pp);
|
|
1604
|
+
c.reset();
|
|
760
1605
|
}
|
|
761
1606
|
|
|
762
|
-
|
|
763
|
-
|
|
1607
|
+
private peekFresh(values: readonly bigint[], prime: number) {
|
|
1608
|
+
while (true) {
|
|
1609
|
+
const hi = this.random.next();
|
|
1610
|
+
const lo = this.random.next();
|
|
1611
|
+
const value = this.normalizeNumeral(BigInt(((hi << 15) | lo) % prime));
|
|
1612
|
+
if (!values.includes(value)) return value;
|
|
1613
|
+
}
|
|
764
1614
|
}
|
|
765
1615
|
|
|
766
|
-
|
|
1616
|
+
private univEval(polynomial: Polynomial, value: bigint) {
|
|
1617
|
+
if (polynomial.size === 0) return 0n;
|
|
1618
|
+
if (this.isConst(polynomial)) return this.normalizeNumeral(polynomial.as[0]);
|
|
1619
|
+
polynomial.lexSort();
|
|
1620
|
+
let result = 0n;
|
|
767
1621
|
for (let index = 0; index < polynomial.size; index++)
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
1622
|
+
result = this.normalizeNumeral(
|
|
1623
|
+
result +
|
|
1624
|
+
this.mulNumeral(
|
|
1625
|
+
polynomial.as[index],
|
|
1626
|
+
this.powerNumeral(value, polynomial.ms[index].totalDegree),
|
|
1627
|
+
),
|
|
1628
|
+
);
|
|
1629
|
+
return result;
|
|
771
1630
|
}
|
|
772
1631
|
|
|
773
|
-
private
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
1632
|
+
private modGcdRec(
|
|
1633
|
+
u: Polynomial,
|
|
1634
|
+
v: Polynomial,
|
|
1635
|
+
prime: number,
|
|
1636
|
+
idx: number,
|
|
1637
|
+
vars: readonly number[],
|
|
1638
|
+
r: PolynomialRef,
|
|
1639
|
+
): boolean {
|
|
1640
|
+
if (idx === vars.length - 1) {
|
|
1641
|
+
this.euclidGcd(u, v, r);
|
|
1642
|
+
return true;
|
|
1643
|
+
}
|
|
1644
|
+
const x = vars[idx];
|
|
1645
|
+
const cU = new PolynomialRef(this);
|
|
1646
|
+
const ppU = new PolynomialRef(this);
|
|
1647
|
+
const lcU = new PolynomialRef(this);
|
|
1648
|
+
const cV = new PolynomialRef(this);
|
|
1649
|
+
const ppV = new PolynomialRef(this);
|
|
1650
|
+
const lcV = new PolynomialRef(this);
|
|
1651
|
+
const cG = new PolynomialRef(this);
|
|
1652
|
+
const lcG = new PolynomialRef(this);
|
|
1653
|
+
const u1 = new PolynomialRef(this);
|
|
1654
|
+
const v1 = new PolynomialRef(this);
|
|
1655
|
+
const q = new PolynomialRef(this);
|
|
1656
|
+
const h = new PolynomialRef(this);
|
|
1657
|
+
const c = new PolynomialRef(this);
|
|
1658
|
+
const lcH = new PolynomialRef(this);
|
|
1659
|
+
try {
|
|
1660
|
+
const ciU = this.iccpZpX(u, x, cU, ppU);
|
|
1661
|
+
const ciV = this.iccpZpX(v, x, cV, ppV);
|
|
1662
|
+
lcU.set(this.lcGlexZpX(ppU.get(), x));
|
|
1663
|
+
lcV.set(this.lcGlexZpX(ppV.get(), x));
|
|
1664
|
+
const ciG = getGcd(ciU, ciV);
|
|
1665
|
+
this.euclidGcd(cU.get(), cV.get(), cG);
|
|
1666
|
+
this.euclidGcd(lcU.get(), lcV.get(), lcG);
|
|
1667
|
+
const skeleton = this.mgcdSkeletons[idx];
|
|
1668
|
+
while (this.mgcdInterpolators.length <= idx)
|
|
1669
|
+
this.mgcdInterpolators.push(new NewtonInterpolator(this));
|
|
1670
|
+
const interpolator = this.mgcdInterpolators[idx];
|
|
1671
|
+
const sparseInterpolator = new SparseInterpolator(this, skeleton);
|
|
1672
|
+
let minDegQ = Infinity;
|
|
1673
|
+
while (true) {
|
|
1674
|
+
let value = 0n;
|
|
1675
|
+
let lcGValue = 0n;
|
|
1676
|
+
while (true) {
|
|
1677
|
+
value = this.peekFresh(interpolator.inputs, prime);
|
|
1678
|
+
lcGValue = this.univEval(lcG.get(), value);
|
|
1679
|
+
if (lcGValue !== 0n) break;
|
|
1680
|
+
}
|
|
1681
|
+
u1.set(this.substitute(ppU.get(), [x], [value]));
|
|
1682
|
+
v1.set(this.substitute(ppV.get(), [x], [value]));
|
|
1683
|
+
if (!this.modGcdRec(u1.get(), v1.get(), prime, idx + 1, vars, q)) return false;
|
|
1684
|
+
q.set(this.mkGlexMonic(q.get()));
|
|
1685
|
+
q.set(this.mulConst(lcGValue, q.get()));
|
|
1686
|
+
const qVar = this.maxVar(q.get());
|
|
1687
|
+
const degQ = qVar === NULL_VAR ? 0 : this.degree(q.get(), qVar);
|
|
1688
|
+
if (degQ < minDegQ) {
|
|
1689
|
+
minDegQ = degQ;
|
|
1690
|
+
if (skeleton === null) {
|
|
1691
|
+
interpolator.reset();
|
|
1692
|
+
interpolator.add(value, q.get());
|
|
1693
|
+
} else {
|
|
1694
|
+
sparseInterpolator.reset();
|
|
1695
|
+
if (!sparseInterpolator.add(skeleton, value, q.get())) return false;
|
|
1696
|
+
}
|
|
1697
|
+
} else if (degQ === minDegQ) {
|
|
1698
|
+
if (skeleton === null) interpolator.add(value, q.get());
|
|
1699
|
+
else if (!sparseInterpolator.add(skeleton, value, q.get())) return false;
|
|
1700
|
+
} else continue;
|
|
1701
|
+
let isCandidate = false;
|
|
1702
|
+
if (skeleton === null) {
|
|
1703
|
+
interpolator.mk(x, h);
|
|
1704
|
+
lcH.set(this.lcGlexZpX(h.get(), x));
|
|
1705
|
+
if (this.eq(lcH.get(), lcG.get())) isCandidate = true;
|
|
1706
|
+
} else if (sparseInterpolator.isReady(skeleton)) {
|
|
1707
|
+
if (!sparseInterpolator.mk(skeleton, h)) return false;
|
|
1708
|
+
isCandidate = true;
|
|
1709
|
+
}
|
|
1710
|
+
if (!isCandidate) continue;
|
|
1711
|
+
if (this.degree(h.get(), x) > 0) this.primitiveZpX(h.get(), x, c);
|
|
1712
|
+
else c.set(this.normalize(h.get()));
|
|
1713
|
+
if (this.divides(c.get(), ppU.get()) && this.divides(c.get(), ppV.get())) {
|
|
1714
|
+
r.set(this.mul(cG.get(), c.get()));
|
|
1715
|
+
r.set(this.mulConst(ciG, r.get()));
|
|
1716
|
+
} else if (minDegQ === 0) {
|
|
1717
|
+
r.copy(cG);
|
|
1718
|
+
r.set(this.mulConst(ciG, r.get()));
|
|
1719
|
+
} else if (skeleton !== null) return false;
|
|
1720
|
+
else continue;
|
|
1721
|
+
if (skeleton === null) this.mgcdSkeletons[idx] = new Skeleton(this, h.get(), x);
|
|
1722
|
+
return true;
|
|
780
1723
|
}
|
|
781
|
-
|
|
1724
|
+
} finally {
|
|
1725
|
+
lcH.reset();
|
|
1726
|
+
c.reset();
|
|
1727
|
+
h.reset();
|
|
1728
|
+
q.reset();
|
|
1729
|
+
v1.reset();
|
|
1730
|
+
u1.reset();
|
|
1731
|
+
lcG.reset();
|
|
1732
|
+
cG.reset();
|
|
1733
|
+
lcV.reset();
|
|
1734
|
+
ppV.reset();
|
|
1735
|
+
cV.reset();
|
|
1736
|
+
lcU.reset();
|
|
1737
|
+
ppU.reset();
|
|
1738
|
+
cU.reset();
|
|
1739
|
+
}
|
|
1740
|
+
}
|
|
1741
|
+
|
|
1742
|
+
private modGcd(
|
|
1743
|
+
u: Polynomial,
|
|
1744
|
+
v: Polynomial,
|
|
1745
|
+
uDegrees: readonly [number, number][],
|
|
1746
|
+
vDegrees: readonly [number, number][],
|
|
1747
|
+
r: PolynomialRef,
|
|
1748
|
+
): boolean {
|
|
1749
|
+
const minDegrees = uDegrees.map((entry, index): [number, number] => [
|
|
1750
|
+
entry[0],
|
|
1751
|
+
Math.min(entry[1], vDegrees[index][1]),
|
|
1752
|
+
]);
|
|
1753
|
+
minDegrees.sort((first, second) => first[1] - second[1] || first[0] - second[0]);
|
|
1754
|
+
this.mgcdSkeletons = minDegrees.map(() => null);
|
|
1755
|
+
const vars = minDegrees.map((entry) => entry[0]);
|
|
1756
|
+
const ppU = new PolynomialRef(this);
|
|
1757
|
+
const ppV = new PolynomialRef(this);
|
|
1758
|
+
const uZp = new PolynomialRef(this);
|
|
1759
|
+
const vZp = new PolynomialRef(this);
|
|
1760
|
+
const cStar = new PolynomialRef(this);
|
|
1761
|
+
const q = new PolynomialRef(this);
|
|
1762
|
+
const candidate = new PolynomialRef(this);
|
|
1763
|
+
try {
|
|
1764
|
+
const cU = this.icWithContent(u, ppU);
|
|
1765
|
+
const cV = this.icWithContent(v, ppV);
|
|
1766
|
+
const dA = getGcd(cU, cV);
|
|
1767
|
+
const lcU = ppU.get().as[ppU.get().getGradedLexMaxPos()];
|
|
1768
|
+
const lcV = ppV.get().as[ppV.get().getGradedLexMaxPos()];
|
|
1769
|
+
const lcG = getGcd(lcU, lcV);
|
|
1770
|
+
let bound = 0n;
|
|
1771
|
+
for (const prime of BIG_PRIMES) {
|
|
1772
|
+
const savedModulus = this.modulus;
|
|
1773
|
+
this.setZp(prime);
|
|
1774
|
+
try {
|
|
1775
|
+
uZp.set(this.normalize(ppU.get()));
|
|
1776
|
+
if (uZp.get().size !== ppU.get().size) continue;
|
|
1777
|
+
vZp.set(this.normalize(ppV.get()));
|
|
1778
|
+
if (vZp.get().size !== ppV.get().size) continue;
|
|
1779
|
+
if (!this.modGcdRec(uZp.get(), vZp.get(), Number(prime), 0, vars, q)) return false;
|
|
1780
|
+
q.set(this.mkGlexMonic(q.get()));
|
|
1781
|
+
q.set(this.mulConst(this.normalizeNumeral(lcG), q.get()));
|
|
1782
|
+
} finally {
|
|
1783
|
+
this.modulus = savedModulus;
|
|
1784
|
+
}
|
|
1785
|
+
if (this.isConst(q.get())) {
|
|
1786
|
+
r.set(this.mkConst(dA));
|
|
1787
|
+
return true;
|
|
1788
|
+
}
|
|
1789
|
+
if (cStar.getOrNull() === null) {
|
|
1790
|
+
cStar.copy(q);
|
|
1791
|
+
bound = prime;
|
|
1792
|
+
} else {
|
|
1793
|
+
const maxCStar = cStar.get().ms[cStar.get().getGradedLexMaxPos()];
|
|
1794
|
+
const maxQ = q.get().ms[q.get().getGradedLexMaxPos()];
|
|
1795
|
+
if (gradedLexCompare(maxQ, maxCStar) < 0) {
|
|
1796
|
+
cStar.copy(q);
|
|
1797
|
+
bound = prime;
|
|
1798
|
+
} else bound = this.craCombineImages(q.get(), prime, cStar.get(), bound, cStar);
|
|
1799
|
+
}
|
|
1800
|
+
candidate.set(this.normalize(cStar.get()));
|
|
1801
|
+
const lcCandidate = candidate.get().as[candidate.get().getGradedLexMaxPos()];
|
|
1802
|
+
if (
|
|
1803
|
+
this.dividesNumeral(lcCandidate, lcG) &&
|
|
1804
|
+
this.divides(candidate.get(), ppU.get()) &&
|
|
1805
|
+
this.divides(candidate.get(), ppV.get())
|
|
1806
|
+
) {
|
|
1807
|
+
r.set(this.mulConst(dA, candidate.get()));
|
|
1808
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1809
|
+
return true;
|
|
1810
|
+
}
|
|
1811
|
+
}
|
|
1812
|
+
this.gcdPrs(u, v, this.maxVar(u), r);
|
|
1813
|
+
return true;
|
|
1814
|
+
} finally {
|
|
1815
|
+
candidate.reset();
|
|
1816
|
+
q.reset();
|
|
1817
|
+
cStar.reset();
|
|
1818
|
+
vZp.reset();
|
|
1819
|
+
uZp.reset();
|
|
1820
|
+
ppV.reset();
|
|
1821
|
+
ppU.reset();
|
|
1822
|
+
}
|
|
782
1823
|
}
|
|
783
1824
|
|
|
784
1825
|
private getVarMaxDegrees(polynomial: Polynomial) {
|
|
@@ -787,207 +1828,689 @@ export class PolynomialManager {
|
|
|
787
1828
|
);
|
|
788
1829
|
}
|
|
789
1830
|
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
|
|
1831
|
+
gcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
|
|
1832
|
+
if (this.isZero(u)) {
|
|
1833
|
+
r.set(v);
|
|
1834
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1835
|
+
return;
|
|
1836
|
+
}
|
|
1837
|
+
if (this.isZero(v)) {
|
|
1838
|
+
r.set(u);
|
|
1839
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1840
|
+
return;
|
|
1841
|
+
}
|
|
1842
|
+
if (u === v) {
|
|
1843
|
+
r.set(u);
|
|
1844
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1845
|
+
return;
|
|
1846
|
+
}
|
|
1847
|
+
if (this.isConst(u) || this.isConst(v)) {
|
|
1848
|
+
const iV = this.getIc(v);
|
|
1849
|
+
const iU = this.getIc(u);
|
|
1850
|
+
r.set(this.mkConst(getGcd(iV, iU)));
|
|
1851
|
+
return;
|
|
1852
|
+
}
|
|
1853
|
+
const uDegrees = this.getVarMaxDegrees(u);
|
|
1854
|
+
const vDegrees = this.getVarMaxDegrees(v);
|
|
1855
|
+
const size = Math.min(uDegrees.length, vDegrees.length);
|
|
800
1856
|
for (let index = 0; index < size; index++) {
|
|
801
|
-
const
|
|
802
|
-
const
|
|
803
|
-
if (
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
811
|
-
private gcdContent(polynomial: Polynomial, variable: number, other: Polynomial) {
|
|
812
|
-
const [integer, content] = this.iccp(polynomial, variable);
|
|
813
|
-
return this.gcd(this.mulConst(integer, content), other);
|
|
814
|
-
}
|
|
815
|
-
|
|
816
|
-
private gcdPrs(first: Polynomial, second: Polynomial, variable: number) {
|
|
817
|
-
const [u, v] =
|
|
818
|
-
this.degree(first, variable) < this.degree(second, variable)
|
|
819
|
-
? [second, first]
|
|
820
|
-
: [first, second];
|
|
821
|
-
const [integerU, contentU, primitiveU] = this.iccp(u, variable);
|
|
822
|
-
const [integerV, contentV, primitiveV] = this.iccp(v, variable);
|
|
823
|
-
const contentGcd = this.gcd(contentU, contentV);
|
|
824
|
-
const integerGcd = getGcd(integerU, integerV);
|
|
825
|
-
let ppU = primitiveU;
|
|
826
|
-
let ppV = primitiveV;
|
|
827
|
-
let g = this.one;
|
|
828
|
-
let h = this.one;
|
|
829
|
-
while (true) {
|
|
830
|
-
const delta = this.degree(ppU, variable) - this.degree(ppV, variable);
|
|
831
|
-
const remainder = this.exactPseudoRemainder(ppU, ppV, variable);
|
|
832
|
-
if (remainder.size === 0) {
|
|
833
|
-
const result = this.pp(this.flipSignIfLmNeg(ppV), variable);
|
|
834
|
-
return this.mulConst(integerGcd, this.mul(contentGcd, result));
|
|
1857
|
+
const xu = uDegrees[index][0];
|
|
1858
|
+
const xv = vDegrees[index][0];
|
|
1859
|
+
if (xu < xv) {
|
|
1860
|
+
this.gcdContent(u, xu, v, r);
|
|
1861
|
+
return;
|
|
1862
|
+
}
|
|
1863
|
+
if (xu > xv) {
|
|
1864
|
+
this.gcdContent(v, xv, u, r);
|
|
1865
|
+
return;
|
|
835
1866
|
}
|
|
836
|
-
if (this.isConst(remainder)) return this.mulConst(integerGcd, contentGcd);
|
|
837
|
-
ppU = ppV;
|
|
838
|
-
ppV = this.exactDiv(remainder, g);
|
|
839
|
-
for (let index = 0; index < delta; index++) ppV = this.exactDiv(ppV, h);
|
|
840
|
-
g = this.lc(ppU, variable);
|
|
841
|
-
let newH = this.one;
|
|
842
|
-
for (let index = 0; index < delta; index++) newH = this.mul(newH, g);
|
|
843
|
-
for (let index = 1; index < delta; index++) newH = this.exactDiv(newH, h);
|
|
844
|
-
h = newH;
|
|
845
1867
|
}
|
|
1868
|
+
if (size < uDegrees.length) {
|
|
1869
|
+
this.gcdContent(u, uDegrees[size][0], v, r);
|
|
1870
|
+
return;
|
|
1871
|
+
}
|
|
1872
|
+
if (size < vDegrees.length) {
|
|
1873
|
+
this.gcdContent(v, vDegrees[size][0], u, r);
|
|
1874
|
+
return;
|
|
1875
|
+
}
|
|
1876
|
+
const x = uDegrees[size - 1][0];
|
|
1877
|
+
if (this.modulus !== null) {
|
|
1878
|
+
this.gcdPrs(u, v, x, r);
|
|
1879
|
+
return;
|
|
1880
|
+
}
|
|
1881
|
+
if (this.isUnivariate(u)) {
|
|
1882
|
+
this.uniModGcd(u, v, r);
|
|
1883
|
+
return;
|
|
1884
|
+
}
|
|
1885
|
+
if (!this.modGcd(u, v, uDegrees, vDegrees, r)) this.gcdPrs(u, v, x, r);
|
|
846
1886
|
}
|
|
847
1887
|
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
1888
|
+
squareFree(polynomial: Polynomial, r: PolynomialRef) {
|
|
1889
|
+
if (this.isZero(polynomial)) {
|
|
1890
|
+
r.set(this.zero);
|
|
1891
|
+
return;
|
|
1892
|
+
}
|
|
1893
|
+
if (this.isConst(polynomial)) {
|
|
1894
|
+
r.set(polynomial);
|
|
1895
|
+
return;
|
|
1896
|
+
}
|
|
1897
|
+
const x = this.maxVar(polynomial);
|
|
1898
|
+
const c = new PolynomialRef(this);
|
|
1899
|
+
const pp = new PolynomialRef(this);
|
|
1900
|
+
const integer = this.iccp(polynomial, x, c, pp);
|
|
1901
|
+
const sqfC = new PolynomialRef(this);
|
|
1902
|
+
this.squareFree(c.get(), sqfC);
|
|
1903
|
+
const ppPrime = new PolynomialRef(this);
|
|
1904
|
+
ppPrime.set(this.derivative(pp.get(), x));
|
|
1905
|
+
const g = new PolynomialRef(this);
|
|
1906
|
+
this.gcd(pp.get(), ppPrime.get(), g);
|
|
1907
|
+
const release = () => {
|
|
1908
|
+
g.reset();
|
|
1909
|
+
ppPrime.reset();
|
|
1910
|
+
sqfC.reset();
|
|
1911
|
+
pp.reset();
|
|
1912
|
+
c.reset();
|
|
1913
|
+
};
|
|
1914
|
+
if (this.isConst(g.get())) {
|
|
1915
|
+
if (this.eq(sqfC.get(), c.get())) {
|
|
1916
|
+
r.set(polynomial);
|
|
1917
|
+
release();
|
|
1918
|
+
return;
|
|
855
1919
|
}
|
|
856
|
-
|
|
1920
|
+
} else pp.set(this.exactDiv(pp.get(), g.get()));
|
|
1921
|
+
r.set(this.mulConst(integer, sqfC.get()));
|
|
1922
|
+
r.set(this.mul(r.get(), pp.get()));
|
|
1923
|
+
release();
|
|
857
1924
|
}
|
|
858
1925
|
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
1926
|
+
private squareFreeIn(polynomial: Polynomial, x: number, r: PolynomialRef) {
|
|
1927
|
+
if (this.isZero(polynomial)) {
|
|
1928
|
+
r.set(this.zero);
|
|
1929
|
+
return;
|
|
1930
|
+
}
|
|
1931
|
+
if (this.isConst(polynomial)) {
|
|
1932
|
+
r.set(polynomial);
|
|
1933
|
+
return;
|
|
1934
|
+
}
|
|
1935
|
+
const pPrime = new PolynomialRef(this);
|
|
1936
|
+
pPrime.set(this.derivative(polynomial, x));
|
|
1937
|
+
const g = new PolynomialRef(this);
|
|
1938
|
+
this.gcd(polynomial, pPrime.get(), g);
|
|
1939
|
+
if (this.isConst(g.get())) r.set(polynomial);
|
|
1940
|
+
else r.set(this.exactDiv(polynomial, g.get()));
|
|
1941
|
+
g.reset();
|
|
1942
|
+
pPrime.reset();
|
|
1943
|
+
}
|
|
1944
|
+
|
|
1945
|
+
private isSquareFreeIn(polynomial: Polynomial, x: number) {
|
|
1946
|
+
const r = new PolynomialRef(this);
|
|
1947
|
+
this.squareFreeIn(polynomial, x, r);
|
|
1948
|
+
const result = polynomial === r.get();
|
|
1949
|
+
r.reset();
|
|
863
1950
|
return result;
|
|
864
1951
|
}
|
|
865
1952
|
|
|
866
|
-
|
|
1953
|
+
pw(polynomial: Polynomial, k: number, r: PolynomialRef) {
|
|
1954
|
+
if (k === 0) {
|
|
1955
|
+
r.set(this.one);
|
|
1956
|
+
return;
|
|
1957
|
+
}
|
|
1958
|
+
if (k === 1) {
|
|
1959
|
+
r.set(polynomial);
|
|
1960
|
+
return;
|
|
1961
|
+
}
|
|
1962
|
+
const result = new PolynomialRef(this);
|
|
1963
|
+
result.set(polynomial);
|
|
1964
|
+
for (let index = 1; index < k; index++) result.set(this.mul(result.get(), polynomial));
|
|
1965
|
+
r.copy(result);
|
|
1966
|
+
result.reset();
|
|
1967
|
+
}
|
|
1968
|
+
|
|
1969
|
+
composeXDivY(polynomial: Polynomial, y: number) {
|
|
1970
|
+
if (this.isConst(polynomial)) return polynomial;
|
|
1971
|
+
const x = this.maxVar(polynomial);
|
|
1972
|
+
const n = this.degree(polynomial, x);
|
|
1973
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
1974
|
+
const k = polynomial.ms[index].degreeOf(x);
|
|
1975
|
+
const vars: number[] = [];
|
|
1976
|
+
const degrees: number[] = [];
|
|
1977
|
+
const push = (variable: number, degree: number) => {
|
|
1978
|
+
if (degree === 0) return;
|
|
1979
|
+
vars.push(variable);
|
|
1980
|
+
degrees.push(degree);
|
|
1981
|
+
};
|
|
1982
|
+
if (x < y) {
|
|
1983
|
+
push(x, k);
|
|
1984
|
+
push(y, n - k);
|
|
1985
|
+
} else {
|
|
1986
|
+
push(y, n - k);
|
|
1987
|
+
push(x, k);
|
|
1988
|
+
}
|
|
1989
|
+
this.cheap.add(polynomial.as[index], this.mkMonomial(vars, degrees));
|
|
1990
|
+
}
|
|
1991
|
+
return this.cheap.mk();
|
|
1992
|
+
}
|
|
1993
|
+
|
|
1994
|
+
private compose(polynomial: Polynomial, q: Polynomial, r: PolynomialRef) {
|
|
867
1995
|
if (this.isConst(polynomial)) {
|
|
868
|
-
|
|
1996
|
+
r.set(polynomial);
|
|
869
1997
|
return;
|
|
870
1998
|
}
|
|
871
|
-
const
|
|
872
|
-
const
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
1999
|
+
const x = this.maxVar(polynomial);
|
|
2000
|
+
const d = this.degree(polynomial, x);
|
|
2001
|
+
const degree2pos = Array.from({ length: d + 1 }, () => -1);
|
|
2002
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
2003
|
+
degree2pos[polynomial.ms[index].totalDegree] = index;
|
|
2004
|
+
r.set(this.mkConst(polynomial.as[degree2pos[d]]));
|
|
2005
|
+
for (let index = 1; index <= d; index++) {
|
|
2006
|
+
const position = degree2pos[d - index];
|
|
2007
|
+
r.set(this.muladd(q, r.get(), position === -1 ? 0n : polynomial.as[position]));
|
|
2008
|
+
}
|
|
2009
|
+
}
|
|
2010
|
+
|
|
2011
|
+
private mkXMinusY(x: number, y: number) {
|
|
2012
|
+
return this.mkLinear([1n, this.normalizeNumeral(-1n)], [x, y], 0n);
|
|
2013
|
+
}
|
|
2014
|
+
|
|
2015
|
+
composeXMinusY(polynomial: Polynomial, y: number, r: PolynomialRef) {
|
|
2016
|
+
const x = this.maxVar(polynomial);
|
|
2017
|
+
if (y === x) {
|
|
2018
|
+
r.set(this.coeff(polynomial, x, 0));
|
|
878
2019
|
return;
|
|
879
2020
|
}
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
2021
|
+
const xMinusY = new PolynomialRef(this);
|
|
2022
|
+
xMinusY.set(this.mkXMinusY(x, y));
|
|
2023
|
+
this.compose(polynomial, xMinusY.get(), r);
|
|
2024
|
+
xMinusY.reset();
|
|
2025
|
+
}
|
|
2026
|
+
|
|
2027
|
+
private pseudoDivisionCore(
|
|
2028
|
+
p: Polynomial,
|
|
2029
|
+
q: Polynomial,
|
|
2030
|
+
x: number,
|
|
2031
|
+
isExact: boolean,
|
|
2032
|
+
isQuotient: boolean,
|
|
2033
|
+
quotient: PolynomialRef,
|
|
2034
|
+
remainder: PolynomialRef,
|
|
2035
|
+
) {
|
|
2036
|
+
const a = p;
|
|
2037
|
+
const b = q;
|
|
2038
|
+
const degA = this.degree(a, x);
|
|
2039
|
+
const degB = this.degree(b, x);
|
|
2040
|
+
if (degB === 0) {
|
|
2041
|
+
remainder.set(this.zero);
|
|
2042
|
+
if (!isQuotient) return 0;
|
|
2043
|
+
if (!isExact) {
|
|
2044
|
+
quotient.set(a);
|
|
2045
|
+
return 1;
|
|
2046
|
+
}
|
|
2047
|
+
const d = degA + 1;
|
|
2048
|
+
if (d === 1) {
|
|
2049
|
+
quotient.set(a);
|
|
2050
|
+
return d;
|
|
2051
|
+
}
|
|
2052
|
+
const bdm1 = new PolynomialRef(this);
|
|
2053
|
+
this.pw(b, d - 1, bdm1);
|
|
2054
|
+
quotient.set(this.mul(a, bdm1.get()));
|
|
2055
|
+
bdm1.reset();
|
|
2056
|
+
return d;
|
|
2057
|
+
}
|
|
2058
|
+
if (degB > degA) {
|
|
2059
|
+
quotient.set(this.zero);
|
|
2060
|
+
remainder.set(a);
|
|
2061
|
+
}
|
|
2062
|
+
const lB = new PolynomialRef(this);
|
|
2063
|
+
const rB = new PolynomialRef(this);
|
|
2064
|
+
lB.set(this.coeffWithReduct(b, x, degB, rB));
|
|
2065
|
+
let d = 0;
|
|
2066
|
+
remainder.set(a);
|
|
2067
|
+
quotient.set(this.zero);
|
|
2068
|
+
while (true) {
|
|
2069
|
+
this.limit.checkpoint();
|
|
2070
|
+
const r = remainder.get();
|
|
2071
|
+
const degR = this.degree(r, x);
|
|
2072
|
+
if (degB > degR) {
|
|
2073
|
+
if (isExact) {
|
|
2074
|
+
const exactD = degA - degB + 1;
|
|
2075
|
+
if (d < exactD) {
|
|
2076
|
+
const lBE = new PolynomialRef(this);
|
|
2077
|
+
this.pw(lB.get(), exactD - d, lBE);
|
|
2078
|
+
if (isQuotient) quotient.set(this.mul(lBE.get(), quotient.get()));
|
|
2079
|
+
remainder.set(this.mul(lBE.get(), remainder.get()));
|
|
2080
|
+
lBE.reset();
|
|
2081
|
+
}
|
|
2082
|
+
}
|
|
2083
|
+
rB.reset();
|
|
2084
|
+
lB.reset();
|
|
2085
|
+
return d;
|
|
2086
|
+
}
|
|
2087
|
+
this.som.reset();
|
|
2088
|
+
this.som2.reset();
|
|
2089
|
+
for (let index = 0; index < r.size; index++) {
|
|
2090
|
+
if (r.size > 100 && index % 100 === 0) this.limit.checkpoint();
|
|
2091
|
+
const monomial = r.ms[index];
|
|
2092
|
+
const coeff = r.as[index];
|
|
2093
|
+
if (monomial.degreeOf(x) === degR) {
|
|
2094
|
+
const shifted = this.divXk(monomial, x, degB);
|
|
2095
|
+
if (isQuotient) this.som2.addTerm(coeff, shifted);
|
|
2096
|
+
this.som.addmul(this.negNumeral(coeff), shifted, rB.get());
|
|
2097
|
+
} else this.som.addmul(coeff, monomial, lB.get());
|
|
2098
|
+
}
|
|
2099
|
+
remainder.set(this.som.mk());
|
|
2100
|
+
if (isQuotient) {
|
|
2101
|
+
const current = quotient.get();
|
|
2102
|
+
for (let index = 0; index < current.size; index++)
|
|
2103
|
+
this.som2.addmul(current.as[index], current.ms[index], lB.get());
|
|
2104
|
+
quotient.set(this.som2.mk());
|
|
2105
|
+
}
|
|
2106
|
+
d++;
|
|
888
2107
|
}
|
|
889
2108
|
}
|
|
890
2109
|
|
|
891
|
-
|
|
892
|
-
const
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
else if (degree === 2) this.factorQuadratic(polynomial, variable, k, result);
|
|
896
|
-
else if (!this.factorMultivariate(polynomial, variable, k, result))
|
|
897
|
-
this.pushFactor(result, polynomial, k);
|
|
2110
|
+
exactPseudoRemainder(p: Polynomial, q: Polynomial, x: number, remainder: PolynomialRef) {
|
|
2111
|
+
const quotient = new PolynomialRef(this);
|
|
2112
|
+
this.pseudoDivisionCore(p, q, x, true, false, quotient, remainder);
|
|
2113
|
+
quotient.reset();
|
|
898
2114
|
}
|
|
899
2115
|
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
|
|
2116
|
+
pseudoRemainder(p: Polynomial, q: Polynomial, x: number, remainder: PolynomialRef) {
|
|
2117
|
+
const quotient = new PolynomialRef(this);
|
|
2118
|
+
const d = this.pseudoDivisionCore(p, q, x, false, false, quotient, remainder);
|
|
2119
|
+
quotient.reset();
|
|
2120
|
+
return d;
|
|
903
2121
|
}
|
|
904
2122
|
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
2123
|
+
exactPseudoDivision(
|
|
2124
|
+
p: Polynomial,
|
|
2125
|
+
q: Polynomial,
|
|
2126
|
+
x: number,
|
|
2127
|
+
quotient: PolynomialRef,
|
|
2128
|
+
remainder: PolynomialRef,
|
|
2129
|
+
) {
|
|
2130
|
+
this.pseudoDivisionCore(p, q, x, true, true, quotient, remainder);
|
|
910
2131
|
}
|
|
911
2132
|
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
2133
|
+
exactDiv(polynomial: Polynomial, divisor: Polynomial) {
|
|
2134
|
+
if (polynomial.size === 0) return polynomial;
|
|
2135
|
+
const remainder = this.som;
|
|
2136
|
+
const quotient = this.som2;
|
|
2137
|
+
remainder.reset();
|
|
2138
|
+
quotient.reset();
|
|
2139
|
+
remainder.add(polynomial);
|
|
2140
|
+
const maxPos = divisor.getGradedLexMaxPos();
|
|
2141
|
+
const divisorMonomial = divisor.ms[maxPos];
|
|
2142
|
+
const divisorCoeff = divisor.as[maxPos];
|
|
2143
|
+
while (true) {
|
|
2144
|
+
this.limit.checkpoint();
|
|
2145
|
+
const remainderPos = remainder.getGradedLexMaxPos();
|
|
2146
|
+
if (remainderPos === -1) {
|
|
2147
|
+
remainder.reset();
|
|
2148
|
+
return quotient.mk();
|
|
2149
|
+
}
|
|
2150
|
+
const monomial = this.divMonomials(remainder.ms[remainderPos], divisorMonomial);
|
|
2151
|
+
if (monomial === null) throw new SmtInvariantError("exact_div: the divisor does not divide");
|
|
2152
|
+
const coeff = this.divNumeral(remainder.as[remainderPos], divisorCoeff);
|
|
2153
|
+
quotient.addTerm(coeff, monomial);
|
|
2154
|
+
remainder.addmul(this.negNumeral(coeff), monomial, divisor);
|
|
2155
|
+
}
|
|
916
2156
|
}
|
|
917
2157
|
|
|
918
|
-
private
|
|
919
|
-
|
|
920
|
-
const
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
|
|
2158
|
+
private divides(divisor: Polynomial, polynomial: Polynomial) {
|
|
2159
|
+
if (polynomial.size === 0) return true;
|
|
2160
|
+
const remainder = this.som;
|
|
2161
|
+
this.som.reset();
|
|
2162
|
+
this.som2.reset();
|
|
2163
|
+
remainder.add(polynomial);
|
|
2164
|
+
const maxPos = divisor.getGradedLexMaxPos();
|
|
2165
|
+
const divisorMonomial = divisor.ms[maxPos];
|
|
2166
|
+
const divisorCoeff = divisor.as[maxPos];
|
|
2167
|
+
while (true) {
|
|
2168
|
+
this.limit.checkpoint();
|
|
2169
|
+
const remainderPos = remainder.getGradedLexMaxPos();
|
|
2170
|
+
if (remainderPos === -1) return true;
|
|
2171
|
+
const monomial = this.divMonomials(remainder.ms[remainderPos], divisorMonomial);
|
|
2172
|
+
if (monomial === null) return false;
|
|
2173
|
+
if (!this.dividesNumeral(divisorCoeff, remainder.as[remainderPos])) return false;
|
|
2174
|
+
const coeff = this.divNumeral(remainder.as[remainderPos], divisorCoeff);
|
|
2175
|
+
remainder.addmul(this.negNumeral(coeff), monomial, divisor);
|
|
2176
|
+
}
|
|
2177
|
+
}
|
|
2178
|
+
|
|
2179
|
+
resultant(p: Polynomial, q: Polynomial, x: number, result: PolynomialRef) {
|
|
2180
|
+
const a = new PolynomialRef(this);
|
|
2181
|
+
const b = new PolynomialRef(this);
|
|
2182
|
+
a.set(p);
|
|
2183
|
+
b.set(q);
|
|
2184
|
+
if (this.isZero(a.get()) || this.isZero(b.get())) {
|
|
2185
|
+
result.set(this.zero);
|
|
2186
|
+
b.reset();
|
|
2187
|
+
a.reset();
|
|
2188
|
+
return;
|
|
2189
|
+
}
|
|
2190
|
+
if (this.isConst(a.get())) {
|
|
2191
|
+
if (this.isConst(b.get())) result.set(this.one);
|
|
2192
|
+
else this.pw(a.get(), this.degree(b.get(), x), result);
|
|
2193
|
+
b.reset();
|
|
2194
|
+
a.reset();
|
|
2195
|
+
return;
|
|
2196
|
+
}
|
|
2197
|
+
if (this.isConst(b.get())) {
|
|
2198
|
+
this.pw(b.get(), this.degree(a.get(), x), result);
|
|
2199
|
+
b.reset();
|
|
2200
|
+
a.reset();
|
|
924
2201
|
return;
|
|
925
2202
|
}
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
|
|
2203
|
+
const cA = new PolynomialRef(this);
|
|
2204
|
+
const cB = new PolynomialRef(this);
|
|
2205
|
+
const ppA = new PolynomialRef(this);
|
|
2206
|
+
const ppB = new PolynomialRef(this);
|
|
2207
|
+
const iA = this.iccp(a.get(), x, cA, ppA);
|
|
2208
|
+
const iB = this.iccp(b.get(), x, cB, ppB);
|
|
2209
|
+
cA.set(this.mulConst(iA, cA.get()));
|
|
2210
|
+
cB.set(this.mulConst(iB, cB.get()));
|
|
2211
|
+
const t = new PolynomialRef(this);
|
|
2212
|
+
this.pw(cA.get(), this.degree(b.get(), x), cA);
|
|
2213
|
+
this.pw(cB.get(), this.degree(a.get(), x), cB);
|
|
2214
|
+
t.set(this.mul(cA.get(), cB.get()));
|
|
2215
|
+
a.copy(ppA);
|
|
2216
|
+
b.copy(ppB);
|
|
2217
|
+
let s = 1;
|
|
2218
|
+
let degA = this.degree(a.get(), x);
|
|
2219
|
+
let degB = this.degree(b.get(), x);
|
|
2220
|
+
if (degA < degB) {
|
|
2221
|
+
a.swap(b);
|
|
2222
|
+
if (degA % 2 === 1 && degB % 2 === 1) s = -1;
|
|
2223
|
+
}
|
|
2224
|
+
const remainder = new PolynomialRef(this);
|
|
2225
|
+
const g = new PolynomialRef(this);
|
|
2226
|
+
const h = new PolynomialRef(this);
|
|
2227
|
+
const newH = new PolynomialRef(this);
|
|
2228
|
+
g.set(this.one);
|
|
2229
|
+
h.set(this.one);
|
|
2230
|
+
while (true) {
|
|
2231
|
+
this.limit.checkpoint();
|
|
2232
|
+
degA = this.degree(a.get(), x);
|
|
2233
|
+
degB = this.degree(b.get(), x);
|
|
2234
|
+
const delta = degA - degB;
|
|
2235
|
+
if (degA % 2 === 1 && degB % 2 === 1) s = -s;
|
|
2236
|
+
this.exactPseudoRemainder(a.get(), b.get(), x, remainder);
|
|
2237
|
+
a.copy(b);
|
|
2238
|
+
b.set(this.exactDiv(remainder.get(), g.get()));
|
|
2239
|
+
for (let index = 0; index < delta; index++) b.set(this.exactDiv(b.get(), h.get()));
|
|
2240
|
+
g.set(this.lc(a.get(), x));
|
|
2241
|
+
newH.set(this.one);
|
|
2242
|
+
this.pw(g.get(), delta, newH);
|
|
2243
|
+
if (delta > 1)
|
|
2244
|
+
for (let index = 0; index < delta - 1; index++)
|
|
2245
|
+
newH.set(this.exactDiv(newH.get(), h.get()));
|
|
2246
|
+
h.copy(newH);
|
|
2247
|
+
if (this.degree(b.get(), x) === 0) {
|
|
2248
|
+
const lastDegA = this.degree(a.get(), x);
|
|
2249
|
+
newH.set(this.lc(b.get(), x));
|
|
2250
|
+
this.pw(newH.get(), lastDegA, newH);
|
|
2251
|
+
if (lastDegA > 1)
|
|
2252
|
+
for (let index = 0; index < lastDegA - 1; index++)
|
|
2253
|
+
newH.set(this.exactDiv(newH.get(), h.get()));
|
|
2254
|
+
h.copy(newH);
|
|
2255
|
+
result.set(this.mul(t.get(), h.get()));
|
|
2256
|
+
if (s < 0) result.set(this.neg(result.get()));
|
|
2257
|
+
newH.reset();
|
|
2258
|
+
h.reset();
|
|
2259
|
+
g.reset();
|
|
2260
|
+
remainder.reset();
|
|
2261
|
+
t.reset();
|
|
2262
|
+
ppB.reset();
|
|
2263
|
+
ppA.reset();
|
|
2264
|
+
cB.reset();
|
|
2265
|
+
cA.reset();
|
|
2266
|
+
b.reset();
|
|
2267
|
+
a.reset();
|
|
2268
|
+
return;
|
|
2269
|
+
}
|
|
2270
|
+
}
|
|
929
2271
|
}
|
|
930
2272
|
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
934
|
-
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
b = this.neg(b);
|
|
939
|
-
c = this.neg(c);
|
|
2273
|
+
discriminant(polynomial: Polynomial, x: number, r: PolynomialRef) {
|
|
2274
|
+
const pPrime = new PolynomialRef(this);
|
|
2275
|
+
const m = this.degree(polynomial, x);
|
|
2276
|
+
if (m === 0) {
|
|
2277
|
+
r.set(this.zero);
|
|
2278
|
+
pPrime.reset();
|
|
2279
|
+
return;
|
|
940
2280
|
}
|
|
941
|
-
|
|
942
|
-
|
|
943
|
-
|
|
2281
|
+
pPrime.set(this.derivative(polynomial, x));
|
|
2282
|
+
this.resultant(polynomial, pPrime.get(), x, r);
|
|
2283
|
+
const isNegated = (m * (m - 1)) % 4 !== 0;
|
|
2284
|
+
const lc = this.getConstCoeff(polynomial, x, m);
|
|
2285
|
+
if (lc !== null) r.set(this.divConst(r.get(), isNegated ? this.negNumeral(lc) : lc));
|
|
2286
|
+
else {
|
|
2287
|
+
if (isNegated) r.set(this.neg(r.get()));
|
|
2288
|
+
const c = new PolynomialRef(this);
|
|
2289
|
+
c.set(this.coeff(polynomial, x, m));
|
|
2290
|
+
r.set(this.exactDiv(r.get(), c.get()));
|
|
2291
|
+
c.reset();
|
|
2292
|
+
}
|
|
2293
|
+
pPrime.reset();
|
|
2294
|
+
}
|
|
2295
|
+
|
|
2296
|
+
private seLazard(d: number, lcSd: Polynomial, sd1: Polynomial, x: number, se: PolynomialRef) {
|
|
2297
|
+
let n = d - this.degree(sd1, x) - 1;
|
|
2298
|
+
if (n === 0) {
|
|
2299
|
+
se.set(sd1);
|
|
944
2300
|
return;
|
|
945
2301
|
}
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
2302
|
+
const xLc = new PolynomialRef(this);
|
|
2303
|
+
xLc.set(this.lc(sd1, x));
|
|
2304
|
+
const y = lcSd;
|
|
2305
|
+
let a = 1 << (31 - Math.clz32(n));
|
|
2306
|
+
const c = new PolynomialRef(this);
|
|
2307
|
+
c.copy(xLc);
|
|
2308
|
+
n -= a;
|
|
2309
|
+
while (a !== 1) {
|
|
2310
|
+
a /= 2;
|
|
2311
|
+
c.set(this.mul(c.get(), c.get()));
|
|
2312
|
+
c.set(this.exactDiv(c.get(), y));
|
|
2313
|
+
if (n >= a) {
|
|
2314
|
+
c.set(this.mul(c.get(), xLc.get()));
|
|
2315
|
+
c.set(this.exactDiv(c.get(), y));
|
|
2316
|
+
n -= a;
|
|
2317
|
+
}
|
|
2318
|
+
}
|
|
2319
|
+
se.set(this.mul(c.get(), sd1));
|
|
2320
|
+
se.set(this.exactDiv(se.get(), y));
|
|
2321
|
+
c.reset();
|
|
2322
|
+
xLc.reset();
|
|
2323
|
+
}
|
|
2324
|
+
|
|
2325
|
+
private optimizedSe1(
|
|
2326
|
+
d: number,
|
|
2327
|
+
e: number,
|
|
2328
|
+
a: Polynomial,
|
|
2329
|
+
sd1: Polynomial,
|
|
2330
|
+
se: Polynomial,
|
|
2331
|
+
s: Polynomial,
|
|
2332
|
+
x: number,
|
|
2333
|
+
se1: PolynomialRef,
|
|
2334
|
+
) {
|
|
2335
|
+
const cD1 = new PolynomialRef(this);
|
|
2336
|
+
const sE = new PolynomialRef(this);
|
|
2337
|
+
const xJ = new PolynomialRef(this);
|
|
2338
|
+
const tmp = new PolynomialRef(this);
|
|
2339
|
+
cD1.set(this.lc(sd1, x));
|
|
2340
|
+
sE.set(this.lc(se, x));
|
|
2341
|
+
const h = new PolynomialRefVector(this);
|
|
2342
|
+
xJ.set(this.one);
|
|
2343
|
+
for (let j = 0; j <= e - 1; j++) {
|
|
2344
|
+
xJ.set(this.mkVar(x, j));
|
|
2345
|
+
h.push(this.mul(sE.get(), xJ.get()));
|
|
2346
|
+
}
|
|
2347
|
+
xJ.set(this.mkVar(x, e));
|
|
2348
|
+
xJ.set(this.mul(sE.get(), xJ.get()));
|
|
2349
|
+
h.push(this.sub(xJ.get(), se));
|
|
2350
|
+
const xPol = new PolynomialRef(this);
|
|
2351
|
+
const xH = new PolynomialRef(this);
|
|
2352
|
+
const xHe = new PolynomialRef(this);
|
|
2353
|
+
xPol.set(this.mkVar(x, 1));
|
|
2354
|
+
for (let j = e + 1; j <= d - 1; j++) {
|
|
2355
|
+
xH.set(this.mul(xPol.get(), h.get(j - 1)));
|
|
2356
|
+
xHe.set(this.coeff(xH.get(), x, e));
|
|
2357
|
+
tmp.set(this.mul(xHe.get(), sd1));
|
|
2358
|
+
tmp.set(this.exactDiv(tmp.get(), cD1.get()));
|
|
2359
|
+
h.push(this.sub(xH.get(), tmp.get()));
|
|
2360
|
+
}
|
|
2361
|
+
const dPolynomial = new PolynomialRef(this);
|
|
2362
|
+
dPolynomial.set(this.zero);
|
|
2363
|
+
for (let j = 0; j < d; j++) {
|
|
2364
|
+
tmp.set(this.coeff(a, x, j));
|
|
2365
|
+
tmp.set(this.mul(tmp.get(), h.get(j)));
|
|
2366
|
+
dPolynomial.set(this.add(dPolynomial.get(), tmp.get()));
|
|
2367
|
+
}
|
|
2368
|
+
const lcA = new PolynomialRef(this);
|
|
2369
|
+
lcA.set(this.lc(a, x));
|
|
2370
|
+
dPolynomial.set(this.exactDiv(dPolynomial.get(), lcA.get()));
|
|
2371
|
+
xH.set(this.mul(xPol.get(), h.get(d - 1)));
|
|
2372
|
+
xHe.set(this.coeff(xH.get(), x, e));
|
|
2373
|
+
xHe.set(this.mul(xHe.get(), sd1));
|
|
2374
|
+
se1.set(this.add(xH.get(), dPolynomial.get()));
|
|
2375
|
+
se1.set(this.mul(cD1.get(), se1.get()));
|
|
2376
|
+
se1.set(this.sub(se1.get(), xHe.get()));
|
|
2377
|
+
se1.set(this.exactDiv(se1.get(), s));
|
|
2378
|
+
if ((d - e + 1) % 2 === 1) se1.set(this.neg(se1.get()));
|
|
2379
|
+
lcA.reset();
|
|
2380
|
+
dPolynomial.reset();
|
|
2381
|
+
xHe.reset();
|
|
2382
|
+
xH.reset();
|
|
2383
|
+
xPol.reset();
|
|
2384
|
+
h.reset();
|
|
2385
|
+
tmp.reset();
|
|
2386
|
+
xJ.reset();
|
|
2387
|
+
sE.reset();
|
|
2388
|
+
cD1.reset();
|
|
2389
|
+
}
|
|
2390
|
+
|
|
2391
|
+
private pscChainOptimizedCore(
|
|
2392
|
+
p: Polynomial,
|
|
2393
|
+
q: Polynomial,
|
|
2394
|
+
x: number,
|
|
2395
|
+
chain: PolynomialRefVector,
|
|
2396
|
+
) {
|
|
2397
|
+
const degP = this.degree(p, x);
|
|
2398
|
+
const degQ = this.degree(q, x);
|
|
2399
|
+
const a = new PolynomialRef(this);
|
|
2400
|
+
const b = new PolynomialRef(this);
|
|
2401
|
+
const c = new PolynomialRef(this);
|
|
2402
|
+
const minusQ = new PolynomialRef(this);
|
|
2403
|
+
const lcQ = new PolynomialRef(this);
|
|
2404
|
+
const ps = new PolynomialRef(this);
|
|
2405
|
+
lcQ.set(this.lc(q, x));
|
|
2406
|
+
const s = new PolynomialRef(this);
|
|
2407
|
+
const release = () => {
|
|
2408
|
+
s.reset();
|
|
2409
|
+
ps.reset();
|
|
2410
|
+
lcQ.reset();
|
|
2411
|
+
minusQ.reset();
|
|
2412
|
+
c.reset();
|
|
2413
|
+
b.reset();
|
|
2414
|
+
a.reset();
|
|
2415
|
+
};
|
|
2416
|
+
this.pw(lcQ.get(), degP - degQ, s);
|
|
2417
|
+
minusQ.set(this.neg(q));
|
|
2418
|
+
a.set(q);
|
|
2419
|
+
this.exactPseudoRemainder(p, minusQ.get(), x, b);
|
|
2420
|
+
while (true) {
|
|
2421
|
+
const d = this.degree(a.get(), x);
|
|
2422
|
+
const e = this.degree(b.get(), x);
|
|
2423
|
+
if (this.isZero(b.get())) {
|
|
2424
|
+
release();
|
|
2425
|
+
return;
|
|
2426
|
+
}
|
|
2427
|
+
ps.set(this.coeff(b.get(), x, d - 1));
|
|
2428
|
+
if (!this.isZero(ps.get())) chain.push(ps.get());
|
|
2429
|
+
const delta = d - e;
|
|
2430
|
+
if (delta > 1) {
|
|
2431
|
+
this.seLazard(d, s.get(), b.get(), x, c);
|
|
2432
|
+
ps.set(this.coeff(c.get(), x, e));
|
|
2433
|
+
if (!this.isZero(ps.get())) chain.push(ps.get());
|
|
2434
|
+
} else c.copy(b);
|
|
2435
|
+
if (e === 0) {
|
|
2436
|
+
release();
|
|
2437
|
+
return;
|
|
2438
|
+
}
|
|
2439
|
+
this.optimizedSe1(d, e, a.get(), b.get(), c.get(), s.get(), x, b);
|
|
2440
|
+
a.copy(c);
|
|
2441
|
+
s.set(this.lc(a.get(), x));
|
|
2442
|
+
}
|
|
2443
|
+
}
|
|
2444
|
+
|
|
2445
|
+
pscChain(p: Polynomial, q: Polynomial, x: number, chain: PolynomialRefVector) {
|
|
2446
|
+
chain.reset();
|
|
2447
|
+
if (this.degree(p, x) >= this.degree(q, x)) this.pscChainOptimizedCore(p, q, x, chain);
|
|
2448
|
+
else this.pscChainOptimizedCore(q, p, x, chain);
|
|
2449
|
+
if (chain.size === 0) chain.push(this.zero);
|
|
2450
|
+
chain.items.reverse();
|
|
2451
|
+
}
|
|
2452
|
+
|
|
2453
|
+
normalize(polynomial: Polynomial) {
|
|
2454
|
+
if (polynomial.size === 0) return polynomial;
|
|
2455
|
+
const modulus = this.modulus;
|
|
2456
|
+
if (modulus !== null) {
|
|
2457
|
+
let index = 0;
|
|
2458
|
+
for (; index < polynomial.size; index++)
|
|
2459
|
+
if (normalizeZp(polynomial.as[index], modulus) !== polynomial.as[index]) break;
|
|
2460
|
+
if (index < polynomial.size) {
|
|
2461
|
+
this.cheap.reset();
|
|
2462
|
+
for (let other = 0; other < polynomial.size; other++)
|
|
2463
|
+
this.cheap.addReset(normalizeZp(polynomial.as[other], modulus), polynomial.ms[other]);
|
|
2464
|
+
this.cheap.normalize();
|
|
2465
|
+
return this.cheap.mk();
|
|
2466
|
+
}
|
|
2467
|
+
}
|
|
2468
|
+
const g = this.gcdNumerals(polynomial.as);
|
|
2469
|
+
if (g === 1n) return polynomial;
|
|
2470
|
+
this.cheap.reset();
|
|
2471
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
2472
|
+
this.cheap.addReset(this.divNumeral(polynomial.as[index], g), polynomial.ms[index]);
|
|
2473
|
+
return this.cheap.mk();
|
|
950
2474
|
}
|
|
951
2475
|
|
|
952
2476
|
private getTermSquareRoot(polynomial: Polynomial, position: number) {
|
|
953
|
-
|
|
954
|
-
if (monomial.degrees.some((degree) => degree % 2 === 1)) return null;
|
|
2477
|
+
if (!polynomial.ms[position].isSquare()) return null;
|
|
955
2478
|
return getExactSquareRoot(polynomial.as[position]);
|
|
956
2479
|
}
|
|
957
2480
|
|
|
958
|
-
sqrt(polynomial: Polynomial) {
|
|
959
|
-
if (polynomial.size === 0)
|
|
960
|
-
|
|
961
|
-
return
|
|
2481
|
+
sqrt(polynomial: Polynomial, r: PolynomialRef) {
|
|
2482
|
+
if (polynomial.size === 0) {
|
|
2483
|
+
r.set(polynomial);
|
|
2484
|
+
return true;
|
|
2485
|
+
}
|
|
2486
|
+
if (this.getTermSquareRoot(polynomial, polynomial.getGradedLexMinPos()) === null) return false;
|
|
962
2487
|
const maxPos = polynomial.getGradedLexMaxPos();
|
|
963
2488
|
const a = this.getTermSquareRoot(polynomial, maxPos);
|
|
964
|
-
if (a === null) return
|
|
965
|
-
const
|
|
966
|
-
const m1 = this.mkMonomial(
|
|
967
|
-
maxMonomial.vars,
|
|
968
|
-
maxMonomial.degrees.map((degree) => degree / 2),
|
|
969
|
-
);
|
|
2489
|
+
if (a === null) return false;
|
|
2490
|
+
const m1 = this.sqrtMonomial(polynomial.ms[maxPos]);
|
|
970
2491
|
const root = this.som;
|
|
971
2492
|
const rest = this.som2;
|
|
972
2493
|
root.reset();
|
|
973
2494
|
rest.reset();
|
|
974
|
-
const twoA =
|
|
2495
|
+
const twoA = a * 2n;
|
|
975
2496
|
root.addTerm(a, m1);
|
|
976
2497
|
for (let index = 0; index < polynomial.size; index++)
|
|
977
2498
|
if (index !== maxPos) rest.addTerm(polynomial.as[index], polynomial.ms[index]);
|
|
978
2499
|
while (true) {
|
|
2500
|
+
this.limit.checkpoint();
|
|
979
2501
|
const restMax = rest.getGradedLexMaxPos();
|
|
980
2502
|
if (restMax === -1) {
|
|
2503
|
+
r.set(root.mk());
|
|
981
2504
|
rest.reset();
|
|
982
|
-
return
|
|
2505
|
+
return true;
|
|
983
2506
|
}
|
|
984
2507
|
const monomial = this.divMonomials(rest.ms[restMax], m1);
|
|
985
|
-
if (monomial === null || rest.as[restMax]
|
|
986
|
-
root.reset();
|
|
2508
|
+
if (monomial === null || !this.dividesNumeral(twoA, rest.as[restMax])) {
|
|
987
2509
|
rest.reset();
|
|
988
|
-
|
|
2510
|
+
root.reset();
|
|
2511
|
+
return false;
|
|
989
2512
|
}
|
|
990
|
-
const coeff =
|
|
2513
|
+
const coeff = this.divNumeral(rest.as[restMax], twoA);
|
|
991
2514
|
const rootSize = root.as.length;
|
|
992
2515
|
for (let index = 0; index < rootSize; index++) {
|
|
993
2516
|
if (root.as[index] === 0n) continue;
|
|
@@ -998,13 +2521,6 @@ export class PolynomialManager {
|
|
|
998
2521
|
}
|
|
999
2522
|
}
|
|
1000
2523
|
|
|
1001
|
-
private getGradedLexMinPos(polynomial: Polynomial) {
|
|
1002
|
-
let minPos = 0;
|
|
1003
|
-
for (let index = 1; index < polynomial.size; index++)
|
|
1004
|
-
if (gradedLexCompare(polynomial.ms[index], polynomial.ms[minPos]) < 0) minPos = index;
|
|
1005
|
-
return minPos;
|
|
1006
|
-
}
|
|
1007
|
-
|
|
1008
2524
|
getVars(polynomial: Polynomial) {
|
|
1009
2525
|
const vars: number[] = [];
|
|
1010
2526
|
for (const monomial of polynomial.ms)
|
|
@@ -1012,11 +2528,22 @@ export class PolynomialManager {
|
|
|
1012
2528
|
return vars;
|
|
1013
2529
|
}
|
|
1014
2530
|
|
|
2531
|
+
private getMaxDegrees(polynomial: Polynomial) {
|
|
2532
|
+
const degrees = new Map<number, number>();
|
|
2533
|
+
for (const monomial of polynomial.ms)
|
|
2534
|
+
for (let index = 0; index < monomial.size; index++) {
|
|
2535
|
+
const variable = monomial.vars[index];
|
|
2536
|
+
if (monomial.degrees[index] > (degrees.get(variable) ?? 0))
|
|
2537
|
+
degrees.set(variable, monomial.degrees[index]);
|
|
2538
|
+
}
|
|
2539
|
+
return degrees;
|
|
2540
|
+
}
|
|
2541
|
+
|
|
1015
2542
|
substitute(polynomial: Polynomial, vars: readonly number[], values: readonly bigint[]) {
|
|
1016
2543
|
this.som.reset();
|
|
1017
2544
|
for (let index = 0; index < polynomial.size; index++) {
|
|
1018
2545
|
const monomial = polynomial.ms[index];
|
|
1019
|
-
let coeff = polynomial.as[index];
|
|
2546
|
+
let coeff = this.normalizeNumeral(polynomial.as[index]);
|
|
1020
2547
|
const keptVars: number[] = [];
|
|
1021
2548
|
const keptDegrees: number[] = [];
|
|
1022
2549
|
for (let power = 0; power < monomial.size; power++) {
|
|
@@ -1024,7 +2551,11 @@ export class PolynomialManager {
|
|
|
1024
2551
|
if (position === -1) {
|
|
1025
2552
|
keptVars.push(monomial.vars[power]);
|
|
1026
2553
|
keptDegrees.push(monomial.degrees[power]);
|
|
1027
|
-
} else
|
|
2554
|
+
} else
|
|
2555
|
+
coeff = this.mulNumeral(
|
|
2556
|
+
this.powerNumeral(values[position], monomial.degrees[power]),
|
|
2557
|
+
coeff,
|
|
2558
|
+
);
|
|
1028
2559
|
}
|
|
1029
2560
|
this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
|
|
1030
2561
|
}
|
|
@@ -1042,9 +2573,11 @@ export class PolynomialManager {
|
|
|
1042
2573
|
this.divX(monomial, variable),
|
|
1043
2574
|
);
|
|
1044
2575
|
}
|
|
1045
|
-
for (let step = 1; step <= degree; step++)
|
|
2576
|
+
for (let step = 1; step <= degree; step++) {
|
|
2577
|
+
this.limit.checkpoint();
|
|
1046
2578
|
for (let power = degree - step; power <= degree - 1; power++)
|
|
1047
2579
|
coeffs[power].addmulBuffer(value, this.unit, coeffs[power + 1]);
|
|
2580
|
+
}
|
|
1048
2581
|
this.som.reset();
|
|
1049
2582
|
for (let power = 0; power <= degree; power++)
|
|
1050
2583
|
this.som.addmulBuffer(1n, this.mkPower(variable, power), coeffs[power]);
|
|
@@ -1079,377 +2612,539 @@ export class PolynomialManager {
|
|
|
1079
2612
|
if (value !== undefined && monomial.degreeOf(variable) === 0)
|
|
1080
2613
|
coeff *= value.den ** BigInt(maxDegree);
|
|
1081
2614
|
}
|
|
1082
|
-
this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
|
|
2615
|
+
if (coeff !== 0n) this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
|
|
1083
2616
|
}
|
|
1084
2617
|
return this.som.mk(true);
|
|
1085
2618
|
}
|
|
1086
2619
|
|
|
1087
|
-
private
|
|
1088
|
-
if (
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
this.
|
|
1093
|
-
|
|
2620
|
+
private mkGlexMonic(polynomial: Polynomial) {
|
|
2621
|
+
if (polynomial.size === 0) return polynomial;
|
|
2622
|
+
const position = polynomial.getGradedLexMaxPos();
|
|
2623
|
+
if (polynomial.as[position] === 1n) return polynomial;
|
|
2624
|
+
const inverse = this.invNumeral(polynomial.as[position]);
|
|
2625
|
+
this.cheap.reset();
|
|
2626
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
2627
|
+
this.cheap.add(this.mulNumeral(polynomial.as[index], inverse), polynomial.ms[index]);
|
|
2628
|
+
return this.cheap.mk();
|
|
1094
2629
|
}
|
|
1095
2630
|
|
|
1096
|
-
private
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
const degree
|
|
1100
|
-
|
|
1101
|
-
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
for (let power = degree - 1; power >= 0; power--)
|
|
1105
|
-
result = this.muladd(inner, result, coeffs[power]);
|
|
2631
|
+
private getMinDegreeVar(polynomial: Polynomial) {
|
|
2632
|
+
let result = NULL_VAR;
|
|
2633
|
+
let minDegree = Infinity;
|
|
2634
|
+
for (const [variable, degree] of this.getMaxDegrees(polynomial))
|
|
2635
|
+
if (degree < minDegree) {
|
|
2636
|
+
result = variable;
|
|
2637
|
+
minDegree = degree;
|
|
2638
|
+
}
|
|
1106
2639
|
return result;
|
|
1107
2640
|
}
|
|
1108
2641
|
|
|
1109
|
-
|
|
1110
|
-
|
|
1111
|
-
|
|
1112
|
-
|
|
2642
|
+
toCoeffs(polynomial: Polynomial) {
|
|
2643
|
+
// Z3's to_numeral_vector builds normalize(p) and drops it, which takes and frees an id.
|
|
2644
|
+
const normalized = this.normalize(polynomial);
|
|
2645
|
+
if (normalized !== polynomial) {
|
|
2646
|
+
this.incRef(normalized);
|
|
2647
|
+
this.decRef(normalized);
|
|
2648
|
+
}
|
|
2649
|
+
const coeffs = Array.from({ length: this.totalDegree(polynomial) + 1 }, () => 0n);
|
|
2650
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
2651
|
+
coeffs[polynomial.ms[index].totalDegree] = polynomial.as[index];
|
|
2652
|
+
return this.um.set(coeffs);
|
|
1113
2653
|
}
|
|
1114
2654
|
|
|
1115
|
-
|
|
1116
|
-
if (
|
|
1117
|
-
|
|
1118
|
-
|
|
1119
|
-
for (let index = 0; index < polynomial.size; index++) {
|
|
1120
|
-
const power = polynomial.ms[index].degreeOf(x);
|
|
1121
|
-
const powers: [number, number][] =
|
|
1122
|
-
x < variable
|
|
1123
|
-
? [
|
|
1124
|
-
[x, power],
|
|
1125
|
-
[variable, degree - power],
|
|
1126
|
-
]
|
|
1127
|
-
: [
|
|
1128
|
-
[variable, degree - power],
|
|
1129
|
-
[x, power],
|
|
1130
|
-
];
|
|
1131
|
-
const kept = powers.filter((entry) => entry[1] > 0);
|
|
1132
|
-
this.cheap.add(
|
|
1133
|
-
polynomial.as[index],
|
|
1134
|
-
this.mkMonomial(
|
|
1135
|
-
kept.map((entry) => entry[0]),
|
|
1136
|
-
kept.map((entry) => entry[1]),
|
|
1137
|
-
),
|
|
1138
|
-
);
|
|
2655
|
+
factor(polynomial: Polynomial, r: Factors) {
|
|
2656
|
+
if (polynomial.size === 0) {
|
|
2657
|
+
r.constant = 0n;
|
|
2658
|
+
return;
|
|
1139
2659
|
}
|
|
1140
|
-
|
|
2660
|
+
this.factorCore(polynomial, r);
|
|
1141
2661
|
}
|
|
1142
2662
|
|
|
1143
|
-
|
|
1144
|
-
if (
|
|
1145
|
-
|
|
1146
|
-
return
|
|
1147
|
-
|
|
1148
|
-
const
|
|
1149
|
-
const
|
|
1150
|
-
const
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
);
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
|
|
1167
|
-
|
|
1168
|
-
|
|
1169
|
-
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
1181
|
-
|
|
2663
|
+
private factorCore(polynomial: Polynomial, r: Factors) {
|
|
2664
|
+
if (this.isConst(polynomial)) {
|
|
2665
|
+
r.constant *= polynomial.as[0];
|
|
2666
|
+
return;
|
|
2667
|
+
}
|
|
2668
|
+
const x = this.getMinDegreeVar(polynomial);
|
|
2669
|
+
const c = new PolynomialRef(this);
|
|
2670
|
+
const pp = new PolynomialRef(this);
|
|
2671
|
+
const integer = this.iccp(polynomial, x, c, pp);
|
|
2672
|
+
r.constant *= integer;
|
|
2673
|
+
this.factorCore(c.get(), r);
|
|
2674
|
+
const cPart = new PolynomialRef(this);
|
|
2675
|
+
cPart.copy(pp);
|
|
2676
|
+
const cPrime = new PolynomialRef(this);
|
|
2677
|
+
cPrime.set(this.derivative(cPart.get(), x));
|
|
2678
|
+
const b = new PolynomialRef(this);
|
|
2679
|
+
const a = new PolynomialRef(this);
|
|
2680
|
+
const d = new PolynomialRef(this);
|
|
2681
|
+
this.gcd(cPart.get(), cPrime.get(), b);
|
|
2682
|
+
if (this.isConst(b.get())) this.factorSqfPp(cPart.get(), r, x, 1);
|
|
2683
|
+
else {
|
|
2684
|
+
a.set(this.exactDiv(cPart.get(), b.get()));
|
|
2685
|
+
for (let j = 1; !this.isConst(a.get()); j++) {
|
|
2686
|
+
this.limit.checkpoint();
|
|
2687
|
+
this.gcd(a.get(), b.get(), d);
|
|
2688
|
+
cPart.set(this.exactDiv(a.get(), d.get()));
|
|
2689
|
+
if (!this.isConst(cPart.get())) this.factorSqfPp(cPart.get(), r, x, j);
|
|
2690
|
+
else if (cPart.get().as[0] === -1n && j % 2 === 1) r.constant = -r.constant;
|
|
2691
|
+
b.set(this.exactDiv(b.get(), d.get()));
|
|
2692
|
+
a.copy(d);
|
|
2693
|
+
}
|
|
2694
|
+
}
|
|
2695
|
+
d.reset();
|
|
2696
|
+
a.reset();
|
|
2697
|
+
b.reset();
|
|
2698
|
+
cPrime.reset();
|
|
2699
|
+
cPart.reset();
|
|
2700
|
+
pp.reset();
|
|
2701
|
+
c.reset();
|
|
2702
|
+
}
|
|
2703
|
+
|
|
2704
|
+
private factorSqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
|
|
2705
|
+
const degree = this.degree(polynomial, x);
|
|
2706
|
+
if (degree === 1) r.push(polynomial, k);
|
|
2707
|
+
else if (this.isUnivariate(polynomial)) this.factorSqfPpUniv(polynomial, r, k);
|
|
2708
|
+
else if (degree === 2) this.factor2SqfPp(polynomial, r, x, k);
|
|
2709
|
+
else this.factorNSqfPp(polynomial, r, x, k);
|
|
2710
|
+
}
|
|
2711
|
+
|
|
2712
|
+
private factor2SqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
|
|
2713
|
+
const a = new PolynomialRef(this);
|
|
2714
|
+
const b = new PolynomialRef(this);
|
|
2715
|
+
const c = new PolynomialRef(this);
|
|
2716
|
+
a.set(this.coeff(polynomial, x, 2));
|
|
2717
|
+
b.set(this.coeff(polynomial, x, 1));
|
|
2718
|
+
c.set(this.coeff(polynomial, x, 0));
|
|
2719
|
+
let isFlipped = false;
|
|
2720
|
+
if (a.get().as[a.get().getGradedLexMaxPos()] < 0n) {
|
|
2721
|
+
a.set(this.neg(a.get()));
|
|
2722
|
+
b.set(this.neg(b.get()));
|
|
2723
|
+
c.set(this.neg(c.get()));
|
|
2724
|
+
isFlipped = true;
|
|
2725
|
+
}
|
|
2726
|
+
const b2 = new PolynomialRef(this);
|
|
2727
|
+
b2.set(this.mul(b.get(), b.get()));
|
|
2728
|
+
const ac = new PolynomialRef(this);
|
|
2729
|
+
ac.set(this.mul(a.get(), c.get()));
|
|
2730
|
+
const disc = new PolynomialRef(this);
|
|
2731
|
+
disc.set(this.addmul(b2.get(), -4n, ac.get()));
|
|
2732
|
+
const discSqrt = new PolynomialRef(this);
|
|
2733
|
+
const f1 = new PolynomialRef(this);
|
|
2734
|
+
const f2 = new PolynomialRef(this);
|
|
2735
|
+
const twoAx = new PolynomialRef(this);
|
|
2736
|
+
if (!this.sqrt(disc.get(), discSqrt)) r.push(polynomial, k);
|
|
2737
|
+
else {
|
|
2738
|
+
if (isFlipped && k % 2 === 1) r.constant = -r.constant;
|
|
2739
|
+
twoAx.set(this.mulTerm(2n, this.mkPower(x, 1), a.get()));
|
|
2740
|
+
f1.set(this.add(twoAx.get(), b.get()));
|
|
2741
|
+
f2.copy(f1);
|
|
2742
|
+
f1.set(this.sub(f1.get(), discSqrt.get()));
|
|
2743
|
+
f2.set(this.add(f2.get(), discSqrt.get()));
|
|
2744
|
+
f1.move(this.pp(f1.get(), x));
|
|
2745
|
+
f2.move(this.pp(f2.get(), x));
|
|
2746
|
+
r.push(f1.get(), k);
|
|
2747
|
+
r.push(f2.get(), k);
|
|
2748
|
+
}
|
|
2749
|
+
twoAx.reset();
|
|
2750
|
+
f2.reset();
|
|
2751
|
+
f1.reset();
|
|
2752
|
+
discSqrt.reset();
|
|
2753
|
+
disc.reset();
|
|
2754
|
+
ac.reset();
|
|
2755
|
+
b2.reset();
|
|
2756
|
+
c.reset();
|
|
2757
|
+
b.reset();
|
|
2758
|
+
a.reset();
|
|
2759
|
+
}
|
|
2760
|
+
|
|
2761
|
+
private factorSqfPpUniv(polynomial: Polynomial, r: Factors, k: number) {
|
|
2762
|
+
const x = this.maxVar(polynomial);
|
|
2763
|
+
const pRef = new PolynomialRef(this);
|
|
2764
|
+
pRef.set(polynomial);
|
|
2765
|
+
const fs = mkFactors();
|
|
2766
|
+
factorSquareFree(this.um, this.toCoeffs(polynomial), fs, 1, DEFAULT_FACTOR_PARAMS);
|
|
2767
|
+
if (fs.factors.length === 1 && fs.degrees[0] === 1) r.push(polynomial, k);
|
|
2768
|
+
else {
|
|
2769
|
+
const f = new PolynomialRef(this);
|
|
2770
|
+
for (let index = 0; index < fs.factors.length; index++) {
|
|
2771
|
+
f.set(this.toPolynomial(fs.factors[index], x));
|
|
2772
|
+
r.push(f.get(), k * fs.degrees[index]);
|
|
1182
2773
|
}
|
|
2774
|
+
if (fs.constant === -1n && k % 2 === 1) r.constant = -r.constant;
|
|
2775
|
+
f.reset();
|
|
1183
2776
|
}
|
|
2777
|
+
pRef.reset();
|
|
1184
2778
|
}
|
|
1185
2779
|
|
|
1186
|
-
private
|
|
1187
|
-
if (this.
|
|
1188
|
-
|
|
2780
|
+
private factorNSqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
|
|
2781
|
+
if (this.isUnivariate(polynomial)) {
|
|
2782
|
+
this.factorSqfPpUniv(polynomial, r, k);
|
|
2783
|
+
return;
|
|
2784
|
+
}
|
|
2785
|
+
if (this.tryMultivarFactor(polynomial, r, x, k)) return;
|
|
2786
|
+
r.push(polynomial, k);
|
|
1189
2787
|
}
|
|
1190
2788
|
|
|
1191
|
-
private
|
|
1192
|
-
|
|
2789
|
+
private pushSmallFactor(part: PolynomialRef, r: Factors, x: number, k: number) {
|
|
2790
|
+
const d = this.degree(part.get(), x);
|
|
2791
|
+
if (d === 1) r.push(part.get(), k);
|
|
2792
|
+
else if (d === 2 && this.isPrimitive(part.get(), x) && this.isSquareFreeIn(part.get(), x))
|
|
2793
|
+
this.factor2SqfPp(part.get(), r, x, k);
|
|
2794
|
+
else r.push(part.get(), k);
|
|
1193
2795
|
}
|
|
1194
2796
|
|
|
1195
|
-
private
|
|
2797
|
+
private tryMultivarFactor(polynomial: Polynomial, r: Factors, x: number, k: number) {
|
|
1196
2798
|
const allVars = this.getVars(polynomial);
|
|
1197
|
-
const mainVars = [
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
1202
|
-
|
|
1203
|
-
.filter((entry) => entry[0] > 1)
|
|
1204
|
-
.map((entry) => entry[1]),
|
|
1205
|
-
];
|
|
2799
|
+
const mainVars = [x];
|
|
2800
|
+
const varsByDegree: [number, number][] = [];
|
|
2801
|
+
for (const variable of allVars)
|
|
2802
|
+
if (variable !== x) varsByDegree.push([this.degree(polynomial, variable), variable]);
|
|
2803
|
+
varsByDegree.sort((first, second) => second[0] - first[0] || second[1] - first[1]);
|
|
2804
|
+
for (const [degree, variable] of varsByDegree) if (degree > 1) mainVars.push(variable);
|
|
1206
2805
|
for (const mainVar of mainVars) {
|
|
1207
2806
|
const degMain = this.degree(polynomial, mainVar);
|
|
1208
2807
|
if (degMain <= 1) continue;
|
|
1209
2808
|
for (const liftVar of allVars) {
|
|
1210
2809
|
if (liftVar === mainVar) continue;
|
|
1211
|
-
|
|
1212
|
-
const
|
|
2810
|
+
this.limit.checkpoint();
|
|
2811
|
+
const evalVars: number[] = [];
|
|
2812
|
+
for (const variable of allVars)
|
|
2813
|
+
if (variable !== mainVar && variable !== liftVar) evalVars.push(variable);
|
|
2814
|
+
const nEval = evalVars.length;
|
|
2815
|
+
const maxCombos = nEval === 0 ? 1 : Math.min(FACTOR_EVAL_VALUES.length, 5);
|
|
1213
2816
|
for (let combo = 0; combo < maxCombos; combo++) {
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
|
|
1220
|
-
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
1224
|
-
|
|
1225
|
-
|
|
1226
|
-
|
|
1227
|
-
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
if (degLift === 0) continue;
|
|
1231
|
-
for (const point of FACTOR_EVAL_VALUES) {
|
|
1232
|
-
const univariate = this.substitute(bivariate, [liftVar], [point]);
|
|
1233
|
-
if (!this.isUnivariate(univariate)) continue;
|
|
1234
|
-
if (this.degree(univariate, mainVar) !== degMain) continue;
|
|
1235
|
-
if (!this.isSquareFreeIn(univariate, mainVar)) continue;
|
|
1236
|
-
const univariateFs = mkFactors();
|
|
1237
|
-
factorSquareFree(
|
|
1238
|
-
this.um,
|
|
1239
|
-
this.um.getPrimitive(this.toCoeffs(univariate)),
|
|
1240
|
-
univariateFs,
|
|
1241
|
-
1,
|
|
1242
|
-
DEFAULT_FACTOR_PARAMS,
|
|
1243
|
-
);
|
|
1244
|
-
const factorCount = univariateFs.factors.length;
|
|
1245
|
-
if (factorCount <= 1) continue;
|
|
1246
|
-
const translated = this.translate(bivariate, liftVar, point);
|
|
1247
|
-
const lcPolynomial = this.coeff(translated, mainVar, degMain);
|
|
1248
|
-
const lcAtZero = this.isConst(lcPolynomial)
|
|
1249
|
-
? (lcPolynomial.as[0] ?? 0n)
|
|
1250
|
-
: this.getConstValue(this.substitute(lcPolynomial, [liftVar], [0n]));
|
|
1251
|
-
if (lcAtZero === null) continue;
|
|
1252
|
-
for (const prime of FACTOR_PRIMES) {
|
|
1253
|
-
if (getGcd(prime, lcAtZero) !== 1n) continue;
|
|
1254
|
-
for (let split = 1; split <= Math.floor(factorCount / 2); split++) {
|
|
1255
|
-
let h1 = univariateFs.factors[0];
|
|
1256
|
-
for (let index = 1; index < split; index++)
|
|
1257
|
-
h1 = this.um.mul(h1, univariateFs.factors[index]);
|
|
1258
|
-
let h2 = univariateFs.factors[split];
|
|
1259
|
-
for (let index = split + 1; index < factorCount; index++)
|
|
1260
|
-
h2 = this.um.mul(h2, univariateFs.factors[index]);
|
|
1261
|
-
const lifted = this.liftBivariate(
|
|
1262
|
-
translated,
|
|
1263
|
-
mainVar,
|
|
1264
|
-
liftVar,
|
|
1265
|
-
degLift,
|
|
1266
|
-
this.um.flipSignIfLmNeg(h1),
|
|
1267
|
-
this.um.flipSignIfLmNeg(h2),
|
|
1268
|
-
lcAtZero,
|
|
1269
|
-
prime,
|
|
1270
|
-
);
|
|
1271
|
-
if (lifted === null) continue;
|
|
1272
|
-
const candidates = lifted.map((factor) => this.translate(factor, liftVar, -point));
|
|
1273
|
-
if (evalVars.length === 0) {
|
|
1274
|
-
for (const candidate of candidates) {
|
|
1275
|
-
if (this.isConst(candidate) || this.degree(candidate, x) === 0) continue;
|
|
1276
|
-
this.pushSmallFactor(candidate, x, k, result);
|
|
1277
|
-
}
|
|
1278
|
-
return true;
|
|
1279
|
-
}
|
|
1280
|
-
for (const candidate of candidates) {
|
|
1281
|
-
if (this.isConst(candidate)) continue;
|
|
1282
|
-
const division = this.exactPseudoDivision(
|
|
1283
|
-
polynomial,
|
|
1284
|
-
candidate,
|
|
1285
|
-
this.maxVar(candidate),
|
|
1286
|
-
);
|
|
1287
|
-
if (division.remainder.size !== 0) continue;
|
|
1288
|
-
if (!this.eq(this.mul(candidate, division.quotient), polynomial)) continue;
|
|
1289
|
-
for (const part of [candidate, division.quotient]) {
|
|
1290
|
-
if (this.isConst(part)) result.constant *= part.as[0];
|
|
1291
|
-
else if (this.degree(part, x) !== 0) this.pushSmallFactor(part, x, k, result);
|
|
1292
|
-
}
|
|
1293
|
-
return true;
|
|
1294
|
-
}
|
|
1295
|
-
}
|
|
1296
|
-
}
|
|
1297
|
-
}
|
|
2817
|
+
this.limit.checkpoint();
|
|
2818
|
+
const pBivar = new PolynomialRef(this);
|
|
2819
|
+
const isFound = this.tryMultivarFactorCombo(
|
|
2820
|
+
polynomial,
|
|
2821
|
+
r,
|
|
2822
|
+
x,
|
|
2823
|
+
k,
|
|
2824
|
+
mainVar,
|
|
2825
|
+
degMain,
|
|
2826
|
+
liftVar,
|
|
2827
|
+
evalVars,
|
|
2828
|
+
combo,
|
|
2829
|
+
pBivar,
|
|
2830
|
+
);
|
|
2831
|
+
pBivar.reset();
|
|
2832
|
+
if (isFound) return true;
|
|
1298
2833
|
}
|
|
1299
2834
|
}
|
|
1300
2835
|
}
|
|
1301
2836
|
return false;
|
|
1302
2837
|
}
|
|
1303
2838
|
|
|
1304
|
-
private
|
|
1305
|
-
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
|
|
2839
|
+
private tryMultivarFactorCombo(
|
|
2840
|
+
polynomial: Polynomial,
|
|
2841
|
+
r: Factors,
|
|
2842
|
+
x: number,
|
|
2843
|
+
k: number,
|
|
2844
|
+
mainVar: number,
|
|
2845
|
+
degMain: number,
|
|
2846
|
+
liftVar: number,
|
|
2847
|
+
evalVars: readonly number[],
|
|
2848
|
+
combo: number,
|
|
2849
|
+
pBivar: PolynomialRef,
|
|
2850
|
+
) {
|
|
2851
|
+
const nEval = evalVars.length;
|
|
2852
|
+
if (nEval > 0) {
|
|
2853
|
+
const evalValues: bigint[] = [];
|
|
2854
|
+
for (let index = 0; index < nEval; index++) {
|
|
2855
|
+
let c = combo;
|
|
2856
|
+
for (let skip = 0; skip < index; skip++) c = Math.floor(c / FACTOR_EVAL_VALUES.length);
|
|
2857
|
+
evalValues.push(FACTOR_EVAL_VALUES[c % FACTOR_EVAL_VALUES.length]);
|
|
2858
|
+
}
|
|
2859
|
+
pBivar.set(this.substitute(polynomial, evalVars, evalValues));
|
|
2860
|
+
} else pBivar.set(polynomial);
|
|
2861
|
+
if (this.degree(pBivar.get(), mainVar) !== degMain) return false;
|
|
2862
|
+
const degLift = this.degree(pBivar.get(), liftVar);
|
|
2863
|
+
if (degLift === 0) return false;
|
|
2864
|
+
for (const point of FACTOR_EVAL_VALUES) {
|
|
2865
|
+
const pUniv = new PolynomialRef(this);
|
|
2866
|
+
const pUnivRef = new PolynomialRef(this);
|
|
2867
|
+
const q = new PolynomialRef(this);
|
|
2868
|
+
const lcPoly = new PolynomialRef(this);
|
|
2869
|
+
const isFound = this.tryMultivarFactorPoint(
|
|
2870
|
+
polynomial,
|
|
2871
|
+
r,
|
|
2872
|
+
x,
|
|
2873
|
+
k,
|
|
2874
|
+
mainVar,
|
|
2875
|
+
degMain,
|
|
2876
|
+
liftVar,
|
|
2877
|
+
nEval,
|
|
2878
|
+
degLift,
|
|
2879
|
+
point,
|
|
2880
|
+
pBivar,
|
|
2881
|
+
pUniv,
|
|
2882
|
+
pUnivRef,
|
|
2883
|
+
q,
|
|
2884
|
+
lcPoly,
|
|
2885
|
+
);
|
|
2886
|
+
lcPoly.reset();
|
|
2887
|
+
q.reset();
|
|
2888
|
+
pUnivRef.reset();
|
|
2889
|
+
pUniv.reset();
|
|
2890
|
+
if (isFound) return true;
|
|
2891
|
+
}
|
|
2892
|
+
return false;
|
|
2893
|
+
}
|
|
2894
|
+
|
|
2895
|
+
private tryMultivarFactorPoint(
|
|
2896
|
+
polynomial: Polynomial,
|
|
2897
|
+
r: Factors,
|
|
2898
|
+
x: number,
|
|
2899
|
+
k: number,
|
|
2900
|
+
mainVar: number,
|
|
2901
|
+
degMain: number,
|
|
2902
|
+
liftVar: number,
|
|
2903
|
+
nEval: number,
|
|
2904
|
+
degLift: number,
|
|
2905
|
+
point: bigint,
|
|
2906
|
+
pBivar: PolynomialRef,
|
|
2907
|
+
pUniv: PolynomialRef,
|
|
2908
|
+
pUnivRef: PolynomialRef,
|
|
2909
|
+
q: PolynomialRef,
|
|
2910
|
+
lcPoly: PolynomialRef,
|
|
2911
|
+
) {
|
|
2912
|
+
pUniv.set(this.substitute(pBivar.get(), [liftVar], [point]));
|
|
2913
|
+
if (!this.isUnivariate(pUniv.get())) return false;
|
|
2914
|
+
if (this.degree(pUniv.get(), mainVar) !== degMain) return false;
|
|
2915
|
+
if (!this.isSquareFreeIn(pUniv.get(), mainVar)) return false;
|
|
2916
|
+
pUnivRef.copy(pUniv);
|
|
2917
|
+
const univariateFs = mkFactors();
|
|
2918
|
+
factorSquareFree(
|
|
2919
|
+
this.um,
|
|
2920
|
+
this.um.getPrimitive(this.toCoeffs(pUnivRef.get())),
|
|
2921
|
+
univariateFs,
|
|
2922
|
+
1,
|
|
2923
|
+
DEFAULT_FACTOR_PARAMS,
|
|
2924
|
+
);
|
|
2925
|
+
const nf = univariateFs.factors.length;
|
|
2926
|
+
if (nf <= 1) return false;
|
|
2927
|
+
q.set(this.translate(pBivar.get(), liftVar, point));
|
|
2928
|
+
lcPoly.set(this.coeff(q.get(), mainVar, degMain));
|
|
2929
|
+
let lcAtZero = 0n;
|
|
2930
|
+
if (this.isConst(lcPoly.get())) lcAtZero = lcPoly.get().as[0] ?? 0n;
|
|
2931
|
+
else {
|
|
2932
|
+
const lcEval = new PolynomialRef(this);
|
|
2933
|
+
lcEval.set(this.substitute(lcPoly.get(), [liftVar], [0n]));
|
|
2934
|
+
const isConstant = this.isConst(lcEval.get());
|
|
2935
|
+
if (isConstant) lcAtZero = lcEval.get().as[0] ?? 0n;
|
|
2936
|
+
lcEval.reset();
|
|
2937
|
+
if (!isConstant) return false;
|
|
2938
|
+
}
|
|
2939
|
+
for (const prime of FACTOR_PRIMES) {
|
|
2940
|
+
if (getGcd(prime, lcAtZero) !== 1n) continue;
|
|
2941
|
+
for (let split = 1; split <= Math.floor(nf / 2); split++) {
|
|
2942
|
+
this.limit.checkpoint();
|
|
2943
|
+
let h1 = this.um.set(univariateFs.factors[0]);
|
|
2944
|
+
for (let index = 1; index < split; index++)
|
|
2945
|
+
h1 = this.um.mul(h1, univariateFs.factors[index]);
|
|
2946
|
+
let h2 = this.um.set(univariateFs.factors[split]);
|
|
2947
|
+
for (let index = split + 1; index < nf; index++)
|
|
2948
|
+
h2 = this.um.mul(h2, univariateFs.factors[index]);
|
|
2949
|
+
if (h1.length > 0 && h1[h1.length - 1] < 0n) h1 = h1.map((coeff) => -coeff);
|
|
2950
|
+
if (h2.length > 0 && h2[h2.length - 1] < 0n) h2 = h2.map((coeff) => -coeff);
|
|
2951
|
+
const f1 = new PolynomialRef(this);
|
|
2952
|
+
const f2 = new PolynomialRef(this);
|
|
2953
|
+
const isFound =
|
|
2954
|
+
this.tryBivarHenselLift(
|
|
2955
|
+
q.get(),
|
|
2956
|
+
mainVar,
|
|
2957
|
+
liftVar,
|
|
2958
|
+
degLift,
|
|
2959
|
+
h1,
|
|
2960
|
+
h2,
|
|
2961
|
+
lcAtZero,
|
|
2962
|
+
prime,
|
|
2963
|
+
f1,
|
|
2964
|
+
f2,
|
|
2965
|
+
) && this.pushLiftedFactors(polynomial, r, x, k, nEval, liftVar, point, f1, f2);
|
|
2966
|
+
f2.reset();
|
|
2967
|
+
f1.reset();
|
|
2968
|
+
if (isFound) return true;
|
|
2969
|
+
}
|
|
2970
|
+
}
|
|
2971
|
+
return false;
|
|
1309
2972
|
}
|
|
1310
2973
|
|
|
1311
|
-
private
|
|
1312
|
-
|
|
1313
|
-
|
|
2974
|
+
private pushLiftedFactors(
|
|
2975
|
+
polynomial: Polynomial,
|
|
2976
|
+
r: Factors,
|
|
2977
|
+
x: number,
|
|
2978
|
+
k: number,
|
|
2979
|
+
nEval: number,
|
|
2980
|
+
liftVar: number,
|
|
2981
|
+
point: bigint,
|
|
2982
|
+
f1: PolynomialRef,
|
|
2983
|
+
f2: PolynomialRef,
|
|
2984
|
+
) {
|
|
2985
|
+
f1.set(this.translate(f1.get(), liftVar, -point));
|
|
2986
|
+
f2.set(this.translate(f2.get(), liftVar, -point));
|
|
2987
|
+
if (nEval === 0) {
|
|
2988
|
+
const bivarFs = [new PolynomialRef(this), new PolynomialRef(this)];
|
|
2989
|
+
bivarFs[0].copy(f1);
|
|
2990
|
+
bivarFs[1].copy(f2);
|
|
2991
|
+
for (const bf of bivarFs) {
|
|
2992
|
+
if (this.isConst(bf.get()) || this.degree(bf.get(), x) === 0) continue;
|
|
2993
|
+
this.pushSmallFactor(bf, r, x, k);
|
|
2994
|
+
}
|
|
2995
|
+
bivarFs[1].reset();
|
|
2996
|
+
bivarFs[0].reset();
|
|
2997
|
+
return true;
|
|
2998
|
+
}
|
|
2999
|
+
const cands = [new PolynomialRef(this), new PolynomialRef(this)];
|
|
3000
|
+
cands[0].copy(f1);
|
|
3001
|
+
cands[1].copy(f2);
|
|
3002
|
+
let isFound = false;
|
|
3003
|
+
for (const cand of cands) {
|
|
3004
|
+
if (this.isConst(cand.get())) continue;
|
|
3005
|
+
const qDiv = new PolynomialRef(this);
|
|
3006
|
+
const rDiv = new PolynomialRef(this);
|
|
3007
|
+
const divVar = this.maxVar(cand.get());
|
|
3008
|
+
this.exactPseudoDivision(polynomial, cand.get(), divVar, qDiv, rDiv);
|
|
3009
|
+
if (!this.isZero(rDiv.get())) {
|
|
3010
|
+
rDiv.reset();
|
|
3011
|
+
qDiv.reset();
|
|
3012
|
+
continue;
|
|
3013
|
+
}
|
|
3014
|
+
const check = new PolynomialRef(this);
|
|
3015
|
+
check.set(this.mul(cand.get(), qDiv.get()));
|
|
3016
|
+
if (this.eq(check.get(), polynomial)) {
|
|
3017
|
+
const parts = [new PolynomialRef(this), new PolynomialRef(this)];
|
|
3018
|
+
parts[0].copy(cand);
|
|
3019
|
+
parts[1].copy(qDiv);
|
|
3020
|
+
for (const part of parts) {
|
|
3021
|
+
if (this.isConst(part.get())) {
|
|
3022
|
+
r.constant *= part.get().as[0];
|
|
3023
|
+
continue;
|
|
3024
|
+
}
|
|
3025
|
+
if (this.degree(part.get(), x) === 0) continue;
|
|
3026
|
+
this.pushSmallFactor(part, r, x, k);
|
|
3027
|
+
}
|
|
3028
|
+
parts[1].reset();
|
|
3029
|
+
parts[0].reset();
|
|
3030
|
+
isFound = true;
|
|
3031
|
+
}
|
|
3032
|
+
check.reset();
|
|
3033
|
+
rDiv.reset();
|
|
3034
|
+
qDiv.reset();
|
|
3035
|
+
if (isFound) break;
|
|
3036
|
+
}
|
|
3037
|
+
cands[1].reset();
|
|
3038
|
+
cands[0].reset();
|
|
3039
|
+
return isFound;
|
|
1314
3040
|
}
|
|
1315
3041
|
|
|
1316
|
-
private
|
|
3042
|
+
private tryBivarHenselLift(
|
|
1317
3043
|
q: Polynomial,
|
|
1318
3044
|
x: number,
|
|
1319
3045
|
y: number,
|
|
1320
3046
|
degY: number,
|
|
1321
3047
|
h1: readonly bigint[],
|
|
1322
3048
|
h2: readonly bigint[],
|
|
1323
|
-
|
|
3049
|
+
lcValue: bigint,
|
|
1324
3050
|
prime: bigint,
|
|
3051
|
+
f1Out: PolynomialRef,
|
|
3052
|
+
f2Out: PolynomialRef,
|
|
1325
3053
|
) {
|
|
1326
|
-
const zp = new UpolynomialManager(prime);
|
|
3054
|
+
const zp = new UpolynomialManager(this.limit, prime);
|
|
1327
3055
|
const f1 = zp.mkMonic(zp.set(h1));
|
|
1328
3056
|
const f2 = zp.mkMonic(zp.set(h2));
|
|
1329
3057
|
const ext = zp.extGcd(f1, f2);
|
|
1330
|
-
if (ext.d.length !== 1 || ext.d[0] !== 1n) return
|
|
3058
|
+
if (ext.d.length !== 1 || ext.d[0] !== 1n) return false;
|
|
1331
3059
|
const qCoeffs: bigint[][] = [];
|
|
1332
|
-
for (let
|
|
1333
|
-
const
|
|
1334
|
-
|
|
1335
|
-
|
|
3060
|
+
for (let j = 0; j <= degY; j++) {
|
|
3061
|
+
const cj = new PolynomialRef(this);
|
|
3062
|
+
cj.set(this.coeff(q, y, j));
|
|
3063
|
+
const isBivariate = this.isZero(cj.get()) || this.isUnivariate(cj.get());
|
|
3064
|
+
if (isBivariate) qCoeffs.push(zp.set(this.isZero(cj.get()) ? [] : this.toCoeffs(cj.get())));
|
|
3065
|
+
cj.reset();
|
|
3066
|
+
if (!isBivariate) return false;
|
|
1336
3067
|
}
|
|
1337
3068
|
const f1Coeffs: bigint[][] = Array.from({ length: degY + 1 }, () => []);
|
|
1338
3069
|
const f2Coeffs: bigint[][] = Array.from({ length: degY + 1 }, () => []);
|
|
1339
3070
|
f1Coeffs[0] = zp.set(f1);
|
|
1340
|
-
f2Coeffs[0] = zp.mulConst(f2, zp.normalizeNumeral(
|
|
1341
|
-
const lcInv = zp.inv(
|
|
1342
|
-
for (let
|
|
1343
|
-
|
|
1344
|
-
|
|
1345
|
-
|
|
1346
|
-
|
|
3071
|
+
f2Coeffs[0] = zp.mulConst(zp.set(f2), zp.normalizeNumeral(lcValue));
|
|
3072
|
+
const lcInv = zp.inv(lcValue);
|
|
3073
|
+
for (let j = 1; j <= degY; j++) {
|
|
3074
|
+
this.limit.checkpoint();
|
|
3075
|
+
let e = zp.set(qCoeffs[j]);
|
|
3076
|
+
for (let first = 0; first <= j; first++) {
|
|
3077
|
+
const second = j - first;
|
|
3078
|
+
if (second > degY) continue;
|
|
3079
|
+
if (first === j && second === 0) continue;
|
|
3080
|
+
if (first === 0 && second === j) continue;
|
|
1347
3081
|
if (f1Coeffs[first].length === 0 || f2Coeffs[second].length === 0) continue;
|
|
1348
|
-
|
|
3082
|
+
e = zp.sub(e, zp.mul(f1Coeffs[first], f2Coeffs[second]));
|
|
1349
3083
|
}
|
|
1350
|
-
if (
|
|
1351
|
-
const a = zp.divRem(zp.mul(
|
|
1352
|
-
const b = zp.divRem(zp.mul(
|
|
1353
|
-
f1Coeffs[
|
|
1354
|
-
f2Coeffs[
|
|
1355
|
-
}
|
|
1356
|
-
const toPolynomial = (coeffs: readonly bigint[][]) => {
|
|
1357
|
-
let result = this.zero;
|
|
1358
|
-
for (let power = 0; power <= degY; power++) {
|
|
1359
|
-
if (coeffs[power].length === 0) continue;
|
|
1360
|
-
const univariate = this.fromCoeffs(coeffs[power], x);
|
|
1361
|
-
if (univariate.size === 0) continue;
|
|
1362
|
-
result = this.add(result, this.mulTerm(1n, this.mkPower(y, power), univariate));
|
|
1363
|
-
}
|
|
1364
|
-
return result;
|
|
1365
|
-
};
|
|
1366
|
-
const first = toPolynomial(f1Coeffs);
|
|
1367
|
-
const second = toPolynomial(f2Coeffs);
|
|
1368
|
-
return this.eq(this.mul(first, second), q) ? [first, second] : null;
|
|
1369
|
-
}
|
|
1370
|
-
|
|
1371
|
-
pscChain(first: Polynomial, second: Polynomial, variable: number) {
|
|
1372
|
-
const chain =
|
|
1373
|
-
this.degree(first, variable) >= this.degree(second, variable)
|
|
1374
|
-
? this.pscChainCore(first, second, variable)
|
|
1375
|
-
: this.pscChainCore(second, first, variable);
|
|
1376
|
-
return chain.length === 0 ? [this.zero] : chain.reverse();
|
|
1377
|
-
}
|
|
1378
|
-
|
|
1379
|
-
private pscChainCore(p: Polynomial, q: Polynomial, x: number) {
|
|
1380
|
-
const chain: Polynomial[] = [];
|
|
1381
|
-
let s = this.pw(this.lc(q, x), this.degree(p, x) - this.degree(q, x));
|
|
1382
|
-
let a = q;
|
|
1383
|
-
let b = this.exactPseudoRemainder(p, this.neg(q), x);
|
|
1384
|
-
while (b.size > 0) {
|
|
1385
|
-
const d = this.degree(a, x);
|
|
1386
|
-
const e = this.degree(b, x);
|
|
1387
|
-
const principal = this.coeff(b, x, d - 1);
|
|
1388
|
-
if (principal.size > 0) chain.push(principal);
|
|
1389
|
-
let c = b;
|
|
1390
|
-
if (d - e > 1) {
|
|
1391
|
-
c = this.getSeLazard(d, s, b, x);
|
|
1392
|
-
const principalE = this.coeff(c, x, e);
|
|
1393
|
-
if (principalE.size > 0) chain.push(principalE);
|
|
1394
|
-
}
|
|
1395
|
-
if (e === 0) break;
|
|
1396
|
-
b = this.getOptimizedSe1(d, e, a, b, c, s, x);
|
|
1397
|
-
a = c;
|
|
1398
|
-
s = this.lc(a, x);
|
|
3084
|
+
if (e.length === 0) continue;
|
|
3085
|
+
const a = zp.divRem(zp.mul(e, ext.v), f1).remainder;
|
|
3086
|
+
const b = zp.divRem(zp.mul(e, ext.u), f2).remainder;
|
|
3087
|
+
f1Coeffs[j] = zp.mulConst(a, lcInv);
|
|
3088
|
+
f2Coeffs[j] = zp.set(b);
|
|
1399
3089
|
}
|
|
1400
|
-
return
|
|
3090
|
+
return this.reconstructLiftedFactors(q, x, y, degY, f1Coeffs, f2Coeffs, f1Out, f2Out);
|
|
1401
3091
|
}
|
|
1402
3092
|
|
|
1403
|
-
private
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
|
|
1413
|
-
|
|
1414
|
-
|
|
1415
|
-
|
|
3093
|
+
private reconstructLiftedFactors(
|
|
3094
|
+
q: Polynomial,
|
|
3095
|
+
x: number,
|
|
3096
|
+
y: number,
|
|
3097
|
+
degY: number,
|
|
3098
|
+
f1Coeffs: readonly bigint[][],
|
|
3099
|
+
f2Coeffs: readonly bigint[][],
|
|
3100
|
+
f1Out: PolynomialRef,
|
|
3101
|
+
f2Out: PolynomialRef,
|
|
3102
|
+
) {
|
|
3103
|
+
const f1Poly = new PolynomialRef(this);
|
|
3104
|
+
const f2Poly = new PolynomialRef(this);
|
|
3105
|
+
f1Poly.set(this.zero);
|
|
3106
|
+
f2Poly.set(this.zero);
|
|
3107
|
+
const addTerm = (coeffs: readonly bigint[], power: number, target: PolynomialRef) => {
|
|
3108
|
+
if (coeffs.length === 0) return;
|
|
3109
|
+
const univ = new PolynomialRef(this);
|
|
3110
|
+
univ.set(this.toPolynomial(coeffs, x));
|
|
3111
|
+
if (!this.isZero(univ.get())) {
|
|
3112
|
+
const term = new PolynomialRef(this);
|
|
3113
|
+
term.set(this.mulTerm(1n, this.mkPower(y, power), univ.get()));
|
|
3114
|
+
target.set(this.add(target.get(), term.get()));
|
|
3115
|
+
term.reset();
|
|
1416
3116
|
}
|
|
3117
|
+
univ.reset();
|
|
3118
|
+
};
|
|
3119
|
+
for (let j = 0; j <= degY; j++) {
|
|
3120
|
+
addTerm(f1Coeffs[j], j, f1Poly);
|
|
3121
|
+
addTerm(f2Coeffs[j], j, f2Poly);
|
|
3122
|
+
}
|
|
3123
|
+
const product = new PolynomialRef(this);
|
|
3124
|
+
product.set(this.mul(f1Poly.get(), f2Poly.get()));
|
|
3125
|
+
const isEqual = this.eq(product.get(), q);
|
|
3126
|
+
if (isEqual) {
|
|
3127
|
+
f1Out.copy(f1Poly);
|
|
3128
|
+
f2Out.copy(f2Poly);
|
|
1417
3129
|
}
|
|
1418
|
-
|
|
3130
|
+
product.reset();
|
|
3131
|
+
f2Poly.reset();
|
|
3132
|
+
f1Poly.reset();
|
|
3133
|
+
return isEqual;
|
|
1419
3134
|
}
|
|
1420
3135
|
|
|
1421
|
-
|
|
1422
|
-
|
|
1423
|
-
|
|
1424
|
-
|
|
1425
|
-
sd1: Polynomial,
|
|
1426
|
-
se: Polynomial,
|
|
1427
|
-
s: Polynomial,
|
|
1428
|
-
x: number,
|
|
1429
|
-
) {
|
|
1430
|
-
const cd1 = this.lc(sd1, x);
|
|
1431
|
-
const lcSe = this.lc(se, x);
|
|
1432
|
-
const getPower = (power: number) => (power === 0 ? this.one : this.mkVar(x, power));
|
|
1433
|
-
const h: Polynomial[] = [];
|
|
1434
|
-
for (let j = 0; j < e; j++) h.push(this.mul(lcSe, getPower(j)));
|
|
1435
|
-
h.push(this.sub(this.mul(lcSe, getPower(e)), se));
|
|
1436
|
-
const xPolynomial = this.mkVar(x);
|
|
1437
|
-
for (let j = e + 1; j < d; j++) {
|
|
1438
|
-
const xh = this.mul(xPolynomial, h[j - 1]);
|
|
1439
|
-
h.push(this.sub(xh, this.exactDiv(this.mul(this.coeff(xh, x, e), sd1), cd1)));
|
|
1440
|
-
}
|
|
1441
|
-
let sum = this.zero;
|
|
1442
|
-
for (let j = 0; j < d; j++) sum = this.add(sum, this.mul(this.coeff(a, x, j), h[j]));
|
|
1443
|
-
const dPolynomial = this.exactDiv(sum, this.lc(a, x));
|
|
1444
|
-
const xh = this.mul(xPolynomial, h[d - 1]);
|
|
1445
|
-
const result = this.exactDiv(
|
|
1446
|
-
this.sub(this.mul(cd1, this.add(xh, dPolynomial)), this.mul(this.coeff(xh, x, e), sd1)),
|
|
1447
|
-
s,
|
|
1448
|
-
);
|
|
1449
|
-
return (d - e + 1) % 2 === 1 ? this.neg(result) : result;
|
|
3136
|
+
evaluateWith<T>(polynomial: Polynomial, ops: ValueOps<T>, getValue: (variable: number) => T) {
|
|
3137
|
+
const result = this.evaluatePartially(polynomial, ops, getValue);
|
|
3138
|
+
if (result === null) throw new SmtInvariantError("a total evaluation stopped early");
|
|
3139
|
+
return result;
|
|
1450
3140
|
}
|
|
1451
3141
|
|
|
1452
|
-
|
|
3142
|
+
// Like Z3's t_eval, this stops at the first variable that getValue has no value for.
|
|
3143
|
+
private evaluatePartially<T>(
|
|
3144
|
+
polynomial: Polynomial,
|
|
3145
|
+
ops: ValueOps<T>,
|
|
3146
|
+
getValue: (variable: number) => T | null,
|
|
3147
|
+
) {
|
|
1453
3148
|
if (polynomial.size === 0) return ops.fromInteger(0n);
|
|
1454
3149
|
if (this.isConst(polynomial)) return ops.fromInteger(polynomial.as[0]);
|
|
1455
3150
|
polynomial.lexSort();
|
|
@@ -1466,34 +3161,38 @@ export class PolynomialManager {
|
|
|
1466
3161
|
private evaluateCore<T>(
|
|
1467
3162
|
polynomial: Polynomial,
|
|
1468
3163
|
ops: ValueOps<T>,
|
|
1469
|
-
getValue: (variable: number) => T,
|
|
3164
|
+
getValue: (variable: number) => T | null,
|
|
1470
3165
|
start: number,
|
|
1471
3166
|
end: number,
|
|
1472
3167
|
x: number,
|
|
1473
|
-
): T {
|
|
3168
|
+
): T | null {
|
|
1474
3169
|
if (end === start + 1) {
|
|
1475
3170
|
let result = ops.fromInteger(polynomial.as[start]);
|
|
1476
3171
|
const monomial = polynomial.ms[start];
|
|
1477
3172
|
for (let index = 0; index < monomial.size; index++) {
|
|
1478
3173
|
const variable = monomial.vars[index];
|
|
1479
3174
|
if (variable > x) break;
|
|
1480
|
-
|
|
3175
|
+
const value = getValue(variable);
|
|
3176
|
+
if (value === null) return null;
|
|
3177
|
+
result = ops.mul(result, ops.power(value, monomial.degrees[index]));
|
|
1481
3178
|
}
|
|
1482
3179
|
return result;
|
|
1483
3180
|
}
|
|
1484
3181
|
const value = getValue(x);
|
|
3182
|
+
if (value === null) return null;
|
|
1485
3183
|
let result = ops.fromInteger(0n);
|
|
1486
3184
|
let index = start;
|
|
1487
3185
|
while (index < end) {
|
|
3186
|
+
this.limit.checkpoint();
|
|
1488
3187
|
const degree = polynomial.ms[index].degreeOf(x);
|
|
1489
3188
|
if (degree === 0) {
|
|
1490
3189
|
const below = this.maxSmallerThan(polynomial, index, end, x);
|
|
1491
|
-
|
|
1492
|
-
result,
|
|
3190
|
+
const rest =
|
|
1493
3191
|
below === NULL_VAR
|
|
1494
3192
|
? ops.fromInteger(polynomial.as[index])
|
|
1495
|
-
: this.evaluateCore(polynomial, ops, getValue, index, end, below)
|
|
1496
|
-
);
|
|
3193
|
+
: this.evaluateCore(polynomial, ops, getValue, index, end, below);
|
|
3194
|
+
if (rest === null) return null;
|
|
3195
|
+
result = ops.add(result, rest);
|
|
1497
3196
|
break;
|
|
1498
3197
|
}
|
|
1499
3198
|
let next = index + 1;
|
|
@@ -1506,13 +3205,12 @@ export class PolynomialManager {
|
|
|
1506
3205
|
}
|
|
1507
3206
|
}
|
|
1508
3207
|
const below = this.maxSmallerThan(polynomial, index, next, x);
|
|
1509
|
-
|
|
1510
|
-
result,
|
|
3208
|
+
const coeff =
|
|
1511
3209
|
below === NULL_VAR
|
|
1512
3210
|
? ops.fromInteger(polynomial.as[index])
|
|
1513
|
-
: this.evaluateCore(polynomial, ops, getValue, index, next, below)
|
|
1514
|
-
);
|
|
1515
|
-
result = ops.mul(result, ops.power(value, degree - nextDegree));
|
|
3211
|
+
: this.evaluateCore(polynomial, ops, getValue, index, next, below);
|
|
3212
|
+
if (coeff === null) return null;
|
|
3213
|
+
result = ops.mul(ops.add(result, coeff), ops.power(value, degree - nextDegree));
|
|
1516
3214
|
index = next;
|
|
1517
3215
|
}
|
|
1518
3216
|
return result;
|
|
@@ -1525,66 +3223,88 @@ export class PolynomialManager {
|
|
|
1525
3223
|
return max;
|
|
1526
3224
|
}
|
|
1527
3225
|
|
|
1528
|
-
|
|
1529
|
-
|
|
1530
|
-
|
|
1531
|
-
|
|
1532
|
-
|
|
1533
|
-
|
|
1534
|
-
|
|
1535
|
-
|
|
1536
|
-
getSign(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
|
|
1537
|
-
const value = this.evaluate(polynomial, values);
|
|
1538
|
-
return value.isZero() ? 0 : value.isPositive() ? 1 : -1;
|
|
3226
|
+
getRationalSign(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
|
|
3227
|
+
const value = this.evaluatePartially(
|
|
3228
|
+
polynomial,
|
|
3229
|
+
RATIONAL_OPS,
|
|
3230
|
+
(variable) => values[variable] ?? null,
|
|
3231
|
+
);
|
|
3232
|
+
return value === null ? null : value.isZero() ? 0 : value.isPositive() ? 1 : -1;
|
|
1539
3233
|
}
|
|
1540
3234
|
}
|
|
1541
3235
|
|
|
1542
3236
|
export class PolynomialCache {
|
|
1543
3237
|
private table = new Map<string, Polynomial>();
|
|
1544
|
-
private
|
|
3238
|
+
private cachedPolys: PolynomialRefVector;
|
|
3239
|
+
private inCache: boolean[] = [];
|
|
1545
3240
|
private pscChains = new Map<string, Polynomial[]>();
|
|
1546
3241
|
private factorizations = new Map<number, Polynomial[]>();
|
|
1547
3242
|
|
|
1548
|
-
constructor(readonly pm: PolynomialManager) {
|
|
3243
|
+
constructor(readonly pm: PolynomialManager) {
|
|
3244
|
+
this.cachedPolys = new PolynomialRefVector(pm);
|
|
3245
|
+
}
|
|
1549
3246
|
|
|
1550
3247
|
reset() {
|
|
1551
3248
|
this.table.clear();
|
|
1552
|
-
this.inCache.clear();
|
|
1553
3249
|
this.pscChains.clear();
|
|
1554
3250
|
this.factorizations.clear();
|
|
3251
|
+
this.inCache = [];
|
|
3252
|
+
this.cachedPolys.reset();
|
|
1555
3253
|
}
|
|
1556
3254
|
|
|
1557
3255
|
mkUnique(polynomial: Polynomial) {
|
|
1558
|
-
if (this.inCache
|
|
3256
|
+
if (this.inCache[polynomial.id] === true) return polynomial;
|
|
1559
3257
|
const key = this.pm.getKey(polynomial);
|
|
1560
3258
|
const existing = this.table.get(key);
|
|
1561
3259
|
if (existing !== undefined) return existing;
|
|
1562
3260
|
this.table.set(key, polynomial);
|
|
1563
|
-
this.
|
|
3261
|
+
this.cachedPolys.push(polynomial);
|
|
3262
|
+
this.inCache[polynomial.id] = true;
|
|
1564
3263
|
return polynomial;
|
|
1565
3264
|
}
|
|
1566
3265
|
|
|
1567
3266
|
contains(polynomial: Polynomial) {
|
|
1568
|
-
return this.inCache
|
|
3267
|
+
return this.inCache[polynomial.id] === true;
|
|
1569
3268
|
}
|
|
1570
3269
|
|
|
1571
|
-
pscChain(first: Polynomial, second: Polynomial, variable: number) {
|
|
3270
|
+
pscChain(first: Polynomial, second: Polynomial, variable: number, chain: PolynomialRefVector) {
|
|
1572
3271
|
const p = this.mkUnique(first);
|
|
1573
3272
|
const q = this.mkUnique(second);
|
|
1574
3273
|
const key = `${p.id},${q.id},${variable}`;
|
|
1575
3274
|
const cached = this.pscChains.get(key);
|
|
1576
|
-
if (cached !== undefined)
|
|
1577
|
-
|
|
1578
|
-
|
|
1579
|
-
|
|
1580
|
-
|
|
1581
|
-
|
|
1582
|
-
|
|
1583
|
-
|
|
1584
|
-
|
|
1585
|
-
|
|
1586
|
-
|
|
1587
|
-
|
|
1588
|
-
|
|
3275
|
+
if (cached !== undefined) {
|
|
3276
|
+
chain.reset();
|
|
3277
|
+
for (const element of cached) chain.push(element);
|
|
3278
|
+
return;
|
|
3279
|
+
}
|
|
3280
|
+
this.pm.pscChain(p, q, variable, chain);
|
|
3281
|
+
const result: Polynomial[] = [];
|
|
3282
|
+
for (let index = 0; index < chain.size; index++) {
|
|
3283
|
+
const unique = this.mkUnique(chain.get(index));
|
|
3284
|
+
chain.set(index, unique);
|
|
3285
|
+
result.push(unique);
|
|
3286
|
+
}
|
|
3287
|
+
this.pscChains.set(key, result);
|
|
3288
|
+
}
|
|
3289
|
+
|
|
3290
|
+
factor(polynomial: Polynomial, distinctFactors: PolynomialRefVector) {
|
|
3291
|
+
distinctFactors.reset();
|
|
3292
|
+
const p = this.mkUnique(polynomial);
|
|
3293
|
+
const cached = this.factorizations.get(p.id);
|
|
3294
|
+
if (cached !== undefined) {
|
|
3295
|
+
distinctFactors.reset();
|
|
3296
|
+
for (const factor of cached) distinctFactors.push(factor);
|
|
3297
|
+
return;
|
|
3298
|
+
}
|
|
3299
|
+
const fs = new Factors(this.pm);
|
|
3300
|
+
this.pm.factor(p, fs);
|
|
3301
|
+
const result: Polynomial[] = [];
|
|
3302
|
+
for (const factor of fs.factors) {
|
|
3303
|
+
const unique = this.mkUnique(factor);
|
|
3304
|
+
distinctFactors.push(unique);
|
|
3305
|
+
result.push(unique);
|
|
3306
|
+
}
|
|
3307
|
+
this.factorizations.set(p.id, result);
|
|
3308
|
+
fs.reset();
|
|
1589
3309
|
}
|
|
1590
3310
|
}
|