tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.94c3dd828
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 +37 -36
- package/dist/deciders.js +55 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +3 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove.cjs +146 -58
- package/dist/prove.js +142 -54
- package/dist/run.cjs +45 -43
- package/dist/run.js +47 -45
- package/dist/transfer.cjs +39 -36
- package/dist/transfer.js +23 -20
- package/dist/worker.cjs +1 -1
- package/dist/worker.js +1 -1
- package/package.json +1 -1
- package/src/ast.ts +3 -3
- package/src/check.ts +203 -33
- package/src/cli/tlapm.ts +261 -68
- package/src/dependencies.ts +23 -2
- package/src/errors.ts +1 -1
- package/src/exit-codes.ts +1 -0
- package/src/liveness-checker.ts +530 -201
- package/src/liveness.ts +47 -32
- package/src/obligations/anonymize.ts +2 -4
- package/src/obligations/index.ts +5 -3
- package/src/obligations/pragma.ts +2 -2
- package/src/parallel.ts +2 -2
- package/src/parser.ts +151 -42
- package/src/prover/deciders.ts +1 -8
- package/src/prover/isabelle/isar/attrib.ts +86 -45
- package/src/prover/isabelle/isar/context.ts +25 -22
- package/src/prover/isabelle/isar/induct.ts +2 -5
- package/src/prover/isabelle/isar/method.ts +5 -7
- package/src/prover/isabelle/isar/proof.ts +33 -16
- package/src/prover/isabelle/isar/rule-cases.ts +6 -14
- package/src/prover/isabelle/isar/theory.ts +16 -17
- package/src/prover/isabelle/isar/toplevel.ts +46 -52
- package/src/prover/isabelle/provers/classical.ts +1 -1
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +1 -0
- package/src/prover/prep/methods.ts +50 -3
- package/src/prover/prep/normalize.ts +4 -1
- package/src/prover/prove.ts +58 -32
- package/src/prover/ptl/decide.ts +43 -63
- package/src/prover/smt/data.ts +51 -45
- package/src/prover/smt/encode.ts +1 -2
- package/src/prover/smt/rewrite.ts +1 -0
- package/src/prover/smt/solver/aig-tactic.ts +25 -15
- package/src/prover/smt/solver/arith-rewriter.ts +3 -5
- package/src/prover/smt/solver/asserted-formulas.ts +1 -1
- package/src/prover/smt/solver/ast-util.ts +3 -1
- package/src/prover/smt/solver/ast.ts +110 -152
- package/src/prover/smt/solver/bound-manager.ts +39 -28
- package/src/prover/smt/solver/bv-bound-chk.ts +2 -8
- package/src/prover/smt/solver/bv-rewriter.ts +14 -16
- package/src/prover/smt/solver/bv1-blast.ts +1 -9
- package/src/prover/smt/solver/cg-table.ts +19 -14
- package/src/prover/smt/solver/check-logic.ts +6 -1
- package/src/prover/smt/solver/context.ts +20 -10
- package/src/prover/smt/solver/demodulator.ts +2 -2
- package/src/prover/smt/solver/dependent-expr-state.ts +16 -0
- package/src/prover/smt/solver/distribute-forall.ts +1 -10
- package/src/prover/smt/solver/dom-simplify.ts +1 -1
- package/src/prover/smt/solver/dt2bv-tactic.ts +2 -7
- package/src/prover/smt/solver/e-matching.ts +6 -6
- package/src/prover/smt/solver/elim-uncnstr.ts +3 -14
- package/src/prover/smt/solver/enode.ts +15 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +19 -8
- package/src/prover/smt/solver/euf/dt-solver.ts +19 -19
- package/src/prover/smt/solver/euf/egraph.ts +65 -32
- package/src/prover/smt/solver/euf/euf-solver.ts +35 -18
- package/src/prover/smt/solver/euf/fpa-solver.ts +37 -51
- package/src/prover/smt/solver/euf/mam.ts +6 -48
- package/src/prover/smt/solver/euf/q-ematch.ts +21 -94
- package/src/prover/smt/solver/euf/q-mbi.ts +4 -2
- package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -1
- package/src/prover/smt/solver/euf/q-solver.ts +2 -0
- package/src/prover/smt/solver/euf/th-solver.ts +1 -1
- package/src/prover/smt/solver/factor.ts +1 -11
- package/src/prover/smt/solver/fd-solver.ts +1 -2
- package/src/prover/smt/solver/fm-tactic.ts +19 -13
- package/src/prover/smt/solver/fpa-rewriter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-converter.ts +10 -6
- package/src/prover/smt/solver/internalizer.ts +41 -2
- package/src/prover/smt/solver/lia2pb.ts +18 -4
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +144 -107
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -17
- package/src/prover/smt/solver/macro-finder.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +13 -13
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -11
- package/src/prover/smt/solver/maxcore.ts +4 -12
- package/src/prover/smt/solver/maxlex.ts +0 -7
- package/src/prover/smt/solver/maxsmt-base.ts +7 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -11
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -9
- package/src/prover/smt/solver/model-evaluator.ts +9 -5
- package/src/prover/smt/solver/model-macro-solver.ts +3 -3
- package/src/prover/smt/solver/muz/dl-context.ts +57 -3
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -20
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -1
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -10
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -13
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -2
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -2
- package/src/prover/smt/solver/muz/dl-rule.ts +93 -29
- package/src/prover/smt/solver/muz/hnf.ts +6 -5
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +14 -3
- package/src/prover/smt/solver/muz/rule-properties.ts +194 -36
- package/src/prover/smt/solver/muz/spacer-context.ts +102 -84
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -2
- package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -3
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +2 -7
- package/src/prover/smt/solver/muz/spacer-util.ts +2 -2
- package/src/prover/smt/solver/muz/substitution.ts +88 -37
- package/src/prover/smt/solver/nlqsat.ts +2 -2
- package/src/prover/smt/solver/nlsat/algebraic.ts +1 -2
- package/src/prover/smt/solver/nlsat/explain.ts +5 -0
- package/src/prover/smt/solver/nlsat/solver.ts +36 -25
- package/src/prover/smt/solver/opt-context.ts +9 -8
- package/src/prover/smt/solver/opt-nlsat.ts +68 -58
- package/src/prover/smt/solver/opt-solver.ts +16 -7
- package/src/prover/smt/solver/optsmt.ts +12 -9
- package/src/prover/smt/solver/pattern-inference.ts +2 -2
- package/src/prover/smt/solver/pb-rewriter.ts +13 -13
- package/src/prover/smt/solver/poly-rewriter.ts +2 -2
- package/src/prover/smt/solver/probes.ts +1 -1
- package/src/prover/smt/solver/propagate-values.ts +4 -0
- package/src/prover/smt/solver/proto-model.ts +5 -5
- package/src/prover/smt/solver/purify-arith.ts +50 -15
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -1
- package/src/prover/smt/solver/qe-mbp.ts +13 -23
- package/src/prover/smt/solver/qe.ts +45 -53
- package/src/prover/smt/solver/qsat.ts +70 -90
- package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
- package/src/prover/smt/solver/quasi-macros.ts +9 -18
- package/src/prover/smt/solver/rational.ts +17 -0
- package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -19
- package/src/prover/smt/solver/recfun-rewriter.ts +1 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +6 -2
- package/src/prover/smt/solver/rewriter.ts +1 -1
- package/src/prover/smt/solver/sat/asymm-branch.ts +59 -46
- package/src/prover/smt/solver/sat/clause-use-list.ts +0 -6
- package/src/prover/smt/solver/sat/clause.ts +1 -3
- package/src/prover/smt/solver/sat/config.ts +3 -3
- package/src/prover/smt/solver/sat/consequences.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +1 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -12
- package/src/prover/smt/solver/sat/model-converter.ts +1 -15
- package/src/prover/smt/solver/sat/pb-solver.ts +49 -23
- package/src/prover/smt/solver/sat/probing.ts +22 -19
- package/src/prover/smt/solver/sat/sat2goal.ts +9 -10
- package/src/prover/smt/solver/sat/simplifier.ts +15 -56
- package/src/prover/smt/solver/sat/solver.ts +20 -19
- package/src/prover/smt/solver/sat/watch-list.ts +7 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +7 -7
- package/src/prover/smt/solver/seq-derive.ts +6 -7
- package/src/prover/smt/solver/seq-eq-solver.ts +7 -7
- package/src/prover/smt/solver/seq-range-predicate.ts +14 -1
- package/src/prover/smt/solver/seq-re-rewriter.ts +1 -10
- package/src/prover/smt/solver/seq-re-util.ts +1 -2
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +4 -4
- package/src/prover/smt/solver/seq-rewriter.ts +1 -4
- package/src/prover/smt/solver/smt-setup.ts +15 -9
- package/src/prover/smt/solver/smtlib-parser.ts +1174 -579
- package/src/prover/smt/solver/smtlib-script.ts +866 -728
- package/src/prover/smt/solver/tactic.ts +66 -14
- package/src/prover/smt/solver/theory-array.ts +25 -58
- package/src/prover/smt/solver/theory-bv.ts +13 -50
- package/src/prover/smt/solver/theory-fpa.ts +46 -78
- package/src/prover/smt/solver/theory-pb.ts +10 -6
- package/src/prover/smt/solver/theory-recfun.ts +2 -2
- package/src/prover/smt/solver/theory-seq-regex.ts +3 -6
- package/src/prover/smt/solver/theory-seq-solve.ts +5 -5
- package/src/prover/smt/solver/theory-seq-state.ts +6 -3
- package/src/prover/smt/solver/theory-seq.ts +32 -54
- package/src/prover/smt/solver/theory.ts +16 -1
- package/src/prover/smt/solver/tseitin-cnf.ts +3 -3
- package/src/prover/smt/solver/var-subst.ts +2 -2
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/zenon/decide.ts +9 -11
- package/src/prover/zenon/node.ts +12 -11
- package/src/prover/zenon/tla/sets.ts +1 -1
- package/src/search.ts +131 -16
- package/src/successors.ts +1 -1
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/summary.ts +29 -14
- package/src/typed-tier.ts +6535 -0
- package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
|
@@ -29,10 +29,9 @@ import {
|
|
|
29
29
|
transitive,
|
|
30
30
|
type Thm,
|
|
31
31
|
} from "../pure/thm";
|
|
32
|
-
import { addUnsafeDest, withClaset } from "../provers/classical";
|
|
33
32
|
import { getLogicFact, getProofContext } from "../tla/context";
|
|
34
33
|
import type { ConstInfo, TlaLogic } from "../tla/logic";
|
|
35
|
-
import {
|
|
34
|
+
import { applyAttributes, getThms } from "./attrib";
|
|
36
35
|
import {
|
|
37
36
|
addAssumptions,
|
|
38
37
|
addFixes,
|
|
@@ -103,6 +102,11 @@ const addConst = (theory: Theory, base: string, type: Typ): Theory => {
|
|
|
103
102
|
};
|
|
104
103
|
};
|
|
105
104
|
|
|
105
|
+
interface NamedFact {
|
|
106
|
+
readonly name: string;
|
|
107
|
+
readonly thms: readonly Thm[];
|
|
108
|
+
}
|
|
109
|
+
|
|
106
110
|
const putTheoryFacts = (theory: Theory, name: string, thms: readonly Thm[]): Theory => ({
|
|
107
111
|
...theory,
|
|
108
112
|
facts: new Map([...theory.facts, [name, thms]]),
|
|
@@ -134,7 +138,16 @@ const define = (
|
|
|
134
138
|
context: IsarContext,
|
|
135
139
|
command: Extract<Command, { kind: "definition" }>,
|
|
136
140
|
): Theory => {
|
|
137
|
-
const [prop] = readStatement(
|
|
141
|
+
const [prop] = readStatement(
|
|
142
|
+
command.name === undefined || command.type === undefined
|
|
143
|
+
? context
|
|
144
|
+
: {
|
|
145
|
+
...context,
|
|
146
|
+
types: new Map([...context.types, [command.name, parseType(command.type)]]),
|
|
147
|
+
},
|
|
148
|
+
[command.part],
|
|
149
|
+
"default",
|
|
150
|
+
).props.flat();
|
|
138
151
|
const [head, args, rhs] = destDef(destEquals(metaRewriteConv(theory.tactics, prop).prop)[1]);
|
|
139
152
|
if (command.name !== undefined && command.name !== head.name)
|
|
140
153
|
throw error(`Head of definition ${head.name} differs from declaration ${command.name}`);
|
|
@@ -153,52 +166,29 @@ const define = (
|
|
|
153
166
|
applied.maxidx + 1,
|
|
154
167
|
applied,
|
|
155
168
|
);
|
|
169
|
+
const [declared, thms] = applyAttributes(context, command.part.attributes, [
|
|
170
|
+
zeroVarIndexes(generalized),
|
|
171
|
+
]);
|
|
156
172
|
return putTheoryFacts(
|
|
157
|
-
addConst(theory, head.name, head.type),
|
|
173
|
+
{ ...addConst(theory, head.name, head.type), tactics: declared.tactics },
|
|
158
174
|
command.part.name ?? `${head.name}_def`,
|
|
159
|
-
|
|
175
|
+
thms,
|
|
160
176
|
);
|
|
161
177
|
};
|
|
162
178
|
|
|
163
|
-
//
|
|
164
|
-
const declare = (
|
|
165
|
-
tactics: ProofContext,
|
|
166
|
-
context: IsarContext,
|
|
167
|
-
references: readonly FactReference[],
|
|
168
|
-
): ProofContext =>
|
|
179
|
+
// Specification.theorems: the declarations of each fact's attributes, whose results it drops.
|
|
180
|
+
const declare = (context: IsarContext, references: readonly FactReference[]): ProofContext =>
|
|
169
181
|
references.reduce(
|
|
170
182
|
(current, reference) =>
|
|
171
|
-
getFact(
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
([declared, thm], attribute) => {
|
|
175
|
-
if (attribute.name !== "dest")
|
|
176
|
-
return [declared, applyAttribute(context, attribute, thm)];
|
|
177
|
-
if (attribute.args.length > 0) throw error("Unsupported dest attribute arguments");
|
|
178
|
-
const classical = declared.classical;
|
|
179
|
-
return [
|
|
180
|
-
{
|
|
181
|
-
...declared,
|
|
182
|
-
classical: withClaset(
|
|
183
|
-
classical,
|
|
184
|
-
addUnsafeDest(classical, thm, declared.atomizeRules),
|
|
185
|
-
),
|
|
186
|
-
},
|
|
187
|
-
thm,
|
|
188
|
-
];
|
|
189
|
-
},
|
|
190
|
-
[inner, fact],
|
|
191
|
-
)[0],
|
|
192
|
-
current,
|
|
193
|
-
),
|
|
194
|
-
tactics,
|
|
195
|
-
);
|
|
183
|
+
applyAttributes(current, reference.attributes, getFact(current, reference.name))[0],
|
|
184
|
+
context,
|
|
185
|
+
).tactics;
|
|
196
186
|
|
|
197
187
|
// Specification.theorem: the statement's elements, then the goal whose results the theory keeps.
|
|
198
188
|
const startTheorem = (
|
|
199
189
|
outer: IsarContext,
|
|
200
190
|
command: Extract<Command, { kind: "theorem" }>,
|
|
201
|
-
store: (
|
|
191
|
+
store: (tactics: ProofContext, facts: readonly NamedFact[]) => void,
|
|
202
192
|
): State => {
|
|
203
193
|
const fixed = command.elements.reduce((context, element) => {
|
|
204
194
|
if (element.kind !== "fixes") return context;
|
|
@@ -223,9 +213,13 @@ const startTheorem = (
|
|
|
223
213
|
);
|
|
224
214
|
let offset = 0;
|
|
225
215
|
const named = assumes.reduce((context, part, index) => {
|
|
226
|
-
const group =
|
|
216
|
+
const [declared, group] = applyAttributes(
|
|
217
|
+
context,
|
|
218
|
+
part.attributes,
|
|
219
|
+
prems.slice(offset, offset + assumeProps[index].length),
|
|
220
|
+
);
|
|
227
221
|
offset += assumeProps[index].length;
|
|
228
|
-
return part.name === undefined ?
|
|
222
|
+
return part.name === undefined ? declared : putFacts(declared, part.name, group);
|
|
229
223
|
}, assumed);
|
|
230
224
|
const elementsContext =
|
|
231
225
|
prems.length === 0 ? named : putFacts(named, command.isLong ? "assms" : "that", prems);
|
|
@@ -237,13 +231,13 @@ const startTheorem = (
|
|
|
237
231
|
normHhfProtect(outer.tactics.limits, exportThm(resultContext, outer, false, result)),
|
|
238
232
|
),
|
|
239
233
|
);
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
],
|
|
245
|
-
|
|
246
|
-
);
|
|
234
|
+
const part = command.shows[0];
|
|
235
|
+
const [notedContext, noted] = applyAttributes(outer, part.attributes, normalized);
|
|
236
|
+
const [namedContext, named] = applyAttributes(notedContext, command.attributes, noted);
|
|
237
|
+
store(namedContext.tactics, [
|
|
238
|
+
...(part.name === undefined ? [] : [{ name: part.name, thms: noted }]),
|
|
239
|
+
...(command.name === undefined ? [] : [{ name: command.name, thms: named }]),
|
|
240
|
+
]);
|
|
247
241
|
});
|
|
248
242
|
};
|
|
249
243
|
|
|
@@ -323,14 +317,14 @@ export const runTheory = (logic: TlaLogic, text: TheoryText, limits: Limits) =>
|
|
|
323
317
|
theory = define(theory, initContext(logic, theory), command);
|
|
324
318
|
break;
|
|
325
319
|
case "declare":
|
|
326
|
-
theory = {
|
|
327
|
-
...theory,
|
|
328
|
-
tactics: declare(theory.tactics, initContext(logic, theory), command.facts),
|
|
329
|
-
};
|
|
320
|
+
theory = { ...theory, tactics: declare(initContext(logic, theory), command.facts) };
|
|
330
321
|
break;
|
|
331
322
|
case "theorem":
|
|
332
|
-
state = startTheorem(initContext(logic, theory), command, (
|
|
333
|
-
theory =
|
|
323
|
+
state = startTheorem(initContext(logic, theory), command, (tactics, facts) => {
|
|
324
|
+
theory = facts.reduce((current, fact) => putTheoryFacts(current, fact.name, fact.thms), {
|
|
325
|
+
...theory,
|
|
326
|
+
tactics,
|
|
327
|
+
});
|
|
334
328
|
});
|
|
335
329
|
break;
|
|
336
330
|
default:
|
package/src/prover/ocaml.ts
CHANGED
|
@@ -1,10 +1,13 @@
|
|
|
1
|
-
|
|
1
|
+
// A bigint is an OCaml int beyond what a number holds exactly.
|
|
2
|
+
type OcamlValue = number | bigint | string | OcamlValue[];
|
|
2
3
|
|
|
3
4
|
export const compareStrings = (left: string, right: string) =>
|
|
4
5
|
left < right ? -1 : left > right ? 1 : 0;
|
|
5
6
|
|
|
6
7
|
export const compareValues = (left: OcamlValue, right: OcamlValue): number => {
|
|
7
8
|
if (typeof left === "number" && typeof right === "number") return left - right;
|
|
9
|
+
if (typeof left === "bigint" && typeof right === "bigint")
|
|
10
|
+
return left < right ? -1 : left > right ? 1 : 0;
|
|
8
11
|
if (typeof left === "string" && typeof right === "string") return compareStrings(left, right);
|
|
9
12
|
if (!Array.isArray(left) || !Array.isArray(right)) return 0;
|
|
10
13
|
const index = left.findIndex(
|
|
@@ -466,6 +466,7 @@ const commuteSequent = createSequentMap(commuteSymbols, "all");
|
|
|
466
466
|
const coalesceSequent = createSequentMap(coalesceModal, "visible");
|
|
467
467
|
|
|
468
468
|
export const processObligation = (sequent: Sequent): Sequent => {
|
|
469
|
+
// Levels.compute_level, whose levels the passes below read on demand: only its errors matter.
|
|
469
470
|
getLevelInfo(undefined, { kind: "Sequent", sequent });
|
|
470
471
|
const keys = sequent.context;
|
|
471
472
|
const expanded = expandUnchangedSequent(keys, expandActionSequent(keys, sequent));
|
|
@@ -77,6 +77,8 @@ const PROVERS: Record<string, { prover: Prover; seconds: number; isBudgeted?: bo
|
|
|
77
77
|
...Object.fromEntries([...FRONTENDS].map((name) => [name, { prover: name, seconds: 0 }])),
|
|
78
78
|
};
|
|
79
79
|
|
|
80
|
+
const UNTIMED_PROVERS = new Set<Prover>(["cooper", "fail", "trivial", ...FRONTENDS]);
|
|
81
|
+
|
|
80
82
|
const getProverMethod = (
|
|
81
83
|
name: string,
|
|
82
84
|
timeout: number | undefined,
|
|
@@ -87,7 +89,10 @@ const getProverMethod = (
|
|
|
87
89
|
if (!known) throw new TlaProverError(`Unknown prover: ${name}`);
|
|
88
90
|
return {
|
|
89
91
|
prover: known.prover,
|
|
90
|
-
timeLimitMs:
|
|
92
|
+
timeLimitMs:
|
|
93
|
+
rlimit !== undefined
|
|
94
|
+
? Infinity
|
|
95
|
+
: ((UNTIMED_PROVERS.has(known.prover) ? undefined : timeout) ?? known.seconds) * 1000,
|
|
91
96
|
...(rlimit !== undefined && { rlimit }),
|
|
92
97
|
...(known.prover === "isabelle" && { tactic: tactic ?? "auto" }),
|
|
93
98
|
};
|
|
@@ -96,9 +101,51 @@ const getProverMethod = (
|
|
|
96
101
|
const BUDGET_FORMS =
|
|
97
102
|
'a number of seconds (wall-clock timeout), or a deterministic Z3 rlimit budget of the form "rN" (e.g. "r5")';
|
|
98
103
|
|
|
104
|
+
const HEX_FLOAT =
|
|
105
|
+
/^[\t-\r ]*[+-]?0x(?=\.?[\da-f])([\da-f]*)\.?([\da-f]*)(?:p([\t-\r ]*[+-]?\d+))?$/i;
|
|
106
|
+
const DECIMAL_FLOAT = /^[\t-\r ]*[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
|
|
107
|
+
const SPECIAL_FLOAT = /^[\t-\r ]*[+-]?(?:(inf(?:inity)?)|nan(?:\([^)]*\))?)$/i;
|
|
108
|
+
|
|
109
|
+
// OCaml's float_of_string_opt: caml_float_of_string drops underscores, then reads a C99 float.
|
|
110
|
+
export const parseOcamlFloat = (text: string) => {
|
|
111
|
+
const digits = text.replaceAll("_", "");
|
|
112
|
+
const sign = digits.trimStart().startsWith("-") ? -1 : 1;
|
|
113
|
+
const hex = HEX_FLOAT.exec(digits);
|
|
114
|
+
if (hex) {
|
|
115
|
+
const mantissa = Number(BigInt(`0x${hex[1]}${hex[2]}`));
|
|
116
|
+
return mantissa === 0 ? 0 : sign * mantissa * 2 ** (Number(hex[3] ?? 0) - 4 * hex[2].length);
|
|
117
|
+
}
|
|
118
|
+
const special = SPECIAL_FLOAT.exec(digits);
|
|
119
|
+
if (special) return special[1] === undefined ? NaN : sign * Infinity;
|
|
120
|
+
return DECIMAL_FLOAT.test(digits) ? Number(digits) : undefined;
|
|
121
|
+
};
|
|
122
|
+
|
|
123
|
+
const OCAML_INT =
|
|
124
|
+
/^([+-]?)(?:0x([\da-f][\da-f_]*)|0o([0-7][0-7_]*)|0b([01][01_]*)|(0u)?(\d[\d_]*))$/i;
|
|
125
|
+
|
|
126
|
+
// OCaml's int_of_string_opt: only an unprefixed decimal is range-checked as a signed 63-bit integer.
|
|
127
|
+
export const parseOcamlInt = (text: string) => {
|
|
128
|
+
const match = OCAML_INT.exec(text);
|
|
129
|
+
if (!match) return undefined;
|
|
130
|
+
const isNegative = match[1] === "-";
|
|
131
|
+
const prefixed =
|
|
132
|
+
match[2] === undefined
|
|
133
|
+
? match[3] === undefined
|
|
134
|
+
? match[4] === undefined
|
|
135
|
+
? match[6]
|
|
136
|
+
: `0b${match[4]}`
|
|
137
|
+
: `0o${match[3]}`
|
|
138
|
+
: `0x${match[2]}`;
|
|
139
|
+
const magnitude = BigInt(prefixed.replaceAll("_", ""));
|
|
140
|
+
const isSigned = prefixed === match[6] && match[5] === undefined;
|
|
141
|
+
if (magnitude > (isSigned ? 2n ** 62n - (isNegative ? 0n : 1n) : 2n ** 63n - 1n))
|
|
142
|
+
return undefined;
|
|
143
|
+
return Number(BigInt.asIntN(63, isNegative ? -magnitude : magnitude));
|
|
144
|
+
};
|
|
145
|
+
|
|
99
146
|
const getRlimit = (budget: string, locus: Locus | undefined) => {
|
|
100
|
-
const count =
|
|
101
|
-
if (!/^[rR]
|
|
147
|
+
const count = parseOcamlFloat(budget.slice(1));
|
|
148
|
+
if (!/^[rR]./s.test(budget) || count === undefined || !Number.isFinite(count) || count <= 0)
|
|
102
149
|
throw new TlaMethodError(
|
|
103
150
|
`Invalid SMT budget ${JSON.stringify(budget)}: expected ${BUDGET_FORMS}.`,
|
|
104
151
|
locus,
|
|
@@ -201,8 +201,11 @@ const expandEnabledCdot = (
|
|
|
201
201
|
throw new TlaProverError("ENABLEDaxioms depends on assumptions of level > 1 \n\n");
|
|
202
202
|
return implicationToEnabled(sequent, locus, onWarning);
|
|
203
203
|
}
|
|
204
|
+
// An obligation has no proof step to label and no instance to expand.
|
|
204
205
|
const anonymizer = createAnonymizer(
|
|
205
|
-
|
|
206
|
+
() => {
|
|
207
|
+
throw new TlapmBugError();
|
|
208
|
+
},
|
|
206
209
|
() => {
|
|
207
210
|
throw new TlapmBugError();
|
|
208
211
|
},
|
package/src/prover/prove.ts
CHANGED
|
@@ -85,14 +85,10 @@ export type ProofAttempt =
|
|
|
85
85
|
errorOutput?: string;
|
|
86
86
|
}
|
|
87
87
|
| { kind: "error"; method: Method }
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
note?: string;
|
|
93
|
-
warning?: string;
|
|
94
|
-
shipped?: string;
|
|
95
|
-
}
|
|
88
|
+
// A frontend whose soundness check failed, or a backend whose encoding failed.
|
|
89
|
+
| { kind: "refused" | "unencoded"; method: Method; reason: string }
|
|
90
|
+
// Cooper's method, which tlapm warns it no longer has.
|
|
91
|
+
| { kind: "unavailable"; method: Method; warning: string; shipped: string }
|
|
96
92
|
| { kind: "skipped"; method: Method; reason: string }
|
|
97
93
|
| {
|
|
98
94
|
kind: "stored" | "reused";
|
|
@@ -292,6 +288,8 @@ export const getFailureReason = (attempt: ProofAttempt) => {
|
|
|
292
288
|
: "false";
|
|
293
289
|
case "error":
|
|
294
290
|
return "false";
|
|
291
|
+
case "unavailable":
|
|
292
|
+
return undefined;
|
|
295
293
|
default:
|
|
296
294
|
return attempt.reason;
|
|
297
295
|
}
|
|
@@ -315,6 +313,7 @@ export const encodeProofTheory = (
|
|
|
315
313
|
name: string,
|
|
316
314
|
reports: ProofReport[],
|
|
317
315
|
obligations: PrintedObligation[],
|
|
316
|
+
isFlattened: boolean,
|
|
318
317
|
) =>
|
|
319
318
|
encodeIsabelleTheory(
|
|
320
319
|
name,
|
|
@@ -324,7 +323,7 @@ export const encodeProofTheory = (
|
|
|
324
323
|
? [
|
|
325
324
|
{
|
|
326
325
|
id: report.obligation.id,
|
|
327
|
-
sequent: shipFirstOrder(normalizeExpand(obligations[index])),
|
|
326
|
+
sequent: shipFirstOrder(normalizeExpand(obligations[index]), isFlattened),
|
|
328
327
|
proof: attempt.proof,
|
|
329
328
|
},
|
|
330
329
|
]
|
|
@@ -404,13 +403,13 @@ const proveWithBackends = async (
|
|
|
404
403
|
const prior = run.results.get(fingerprint)?.get(method.prover);
|
|
405
404
|
return prior?.method.tactic === method.tactic ? prior : undefined;
|
|
406
405
|
};
|
|
407
|
-
const reuse = (prior: ProofAttempt) =>
|
|
406
|
+
const reuse = (prior: ProofAttempt, shipped = "shipped" in prior ? prior.shipped : undefined) =>
|
|
408
407
|
attempts.push({
|
|
409
408
|
kind: "reused",
|
|
410
409
|
method: prior.method,
|
|
411
410
|
isProved: isProvedAttempt(prior),
|
|
412
411
|
reason: getFailureReason(prior),
|
|
413
|
-
shipped
|
|
412
|
+
shipped,
|
|
414
413
|
});
|
|
415
414
|
const record = (attempt: ProofAttempt) => {
|
|
416
415
|
attempts.push(attempt);
|
|
@@ -440,11 +439,31 @@ const proveWithBackends = async (
|
|
|
440
439
|
const prover = FAILING_FRONTENDS.find((name) => methods.frontends.has(name));
|
|
441
440
|
if (prover === undefined) throw expanded;
|
|
442
441
|
record({
|
|
443
|
-
kind: "
|
|
442
|
+
kind: "refused",
|
|
444
443
|
method: { prover, timeLimitMs: Infinity },
|
|
445
444
|
reason: expanded.message,
|
|
446
|
-
note: `${expanded.message}\nObligation:\n\n`,
|
|
447
445
|
});
|
|
446
|
+
// Prep.ship goes on with the obligation normalize_expand left, whose goal is FALSE: it checks
|
|
447
|
+
// that for triviality, then each method still answers from the fingerprints file. A stored
|
|
448
|
+
// failure prints that obligation when ExpandENABLED is cited.
|
|
449
|
+
const falsified: Sequent = {
|
|
450
|
+
...normalizeSequent(expandDefs(obligation.sequent)),
|
|
451
|
+
active: { kind: "Internal", builtin: "FALSE" },
|
|
452
|
+
};
|
|
453
|
+
if (obligation.kind.kind === "Support" && isTrivial(falsified))
|
|
454
|
+
return { obligation: { ...getObligationBase(obligation), status: "trivial" }, attempts };
|
|
455
|
+
for (const method of methods.provers) {
|
|
456
|
+
const prior = method === methods.provers[0] ? firstPrior : getPrior(method);
|
|
457
|
+
if (prior && isProvedAttempt(prior)) {
|
|
458
|
+
reuse(prior);
|
|
459
|
+
return getProvedReport(method.prover);
|
|
460
|
+
}
|
|
461
|
+
if (prior && getBudget(prior.method) >= getBudget(method))
|
|
462
|
+
reuse(
|
|
463
|
+
prior,
|
|
464
|
+
methods.frontends.has("expandenabled") ? `${formatObligation(falsified)}\n` : undefined,
|
|
465
|
+
);
|
|
466
|
+
}
|
|
448
467
|
return getUnprovedReport(
|
|
449
468
|
obligation,
|
|
450
469
|
"failed",
|
|
@@ -482,10 +501,9 @@ const proveWithBackends = async (
|
|
|
482
501
|
if (method.prover === "cooper") {
|
|
483
502
|
const warning = "Cooper's method is not available any more.\n";
|
|
484
503
|
record({
|
|
485
|
-
kind: "
|
|
504
|
+
kind: "unavailable",
|
|
486
505
|
method,
|
|
487
506
|
warning,
|
|
488
|
-
note: `\n\\* ${warning}\n`,
|
|
489
507
|
shipped: `${formatObligation(shipFirstOrder(sequent, run.settings.isFlattened))}\n`,
|
|
490
508
|
});
|
|
491
509
|
failures.push({ reason: warning.trim(), isDecided: true });
|
|
@@ -504,27 +522,35 @@ const proveWithBackends = async (
|
|
|
504
522
|
const name = getTemporaryName();
|
|
505
523
|
const file = `${name}${encoder.suffix}`;
|
|
506
524
|
const chunks: string[] = [];
|
|
525
|
+
const encodingError = (() => {
|
|
526
|
+
try {
|
|
527
|
+
encoder.encode({
|
|
528
|
+
obligation,
|
|
529
|
+
sequent,
|
|
530
|
+
fingerprint,
|
|
531
|
+
method,
|
|
532
|
+
session,
|
|
533
|
+
name,
|
|
534
|
+
settings: run.settings,
|
|
535
|
+
write: (text) => chunks.push(text),
|
|
536
|
+
});
|
|
537
|
+
return undefined;
|
|
538
|
+
} catch (error: unknown) {
|
|
539
|
+
return error;
|
|
540
|
+
}
|
|
541
|
+
})();
|
|
542
|
+
const text = chunks.join("");
|
|
507
543
|
// A failed encoding leaves the file as far as it got.
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
session,
|
|
515
|
-
name,
|
|
516
|
-
settings: run.settings,
|
|
517
|
-
write: (text) => chunks.push(text),
|
|
544
|
+
run.settings.onInput?.(file, text);
|
|
545
|
+
if (encodingError instanceof TlaProverError) {
|
|
546
|
+
record({ kind: "unencoded", method, reason: encodingError.message });
|
|
547
|
+
failures.push({
|
|
548
|
+
reason: `${method.prover} failed: ${encodingError.message}`,
|
|
549
|
+
isDecided: true,
|
|
518
550
|
});
|
|
519
|
-
} catch (error) {
|
|
520
|
-
if (!(error instanceof TlaProverError)) throw error;
|
|
521
|
-
record({ kind: "failed", method, reason: error.message });
|
|
522
|
-
failures.push({ reason: `${method.prover} failed: ${error.message}`, isDecided: true });
|
|
523
551
|
continue;
|
|
524
|
-
} finally {
|
|
525
|
-
run.settings.onInput?.(file, chunks.join(""));
|
|
526
552
|
}
|
|
527
|
-
|
|
553
|
+
if (encodingError !== undefined) throw encodingError;
|
|
528
554
|
const timeLimitMs = Math.max(method.timeLimitMs, BACKEND_WAIT_MS);
|
|
529
555
|
const decision =
|
|
530
556
|
method.prover === "smt" && run.settings.solveSmt
|
package/src/prover/ptl/decide.ts
CHANGED
|
@@ -1,4 +1,3 @@
|
|
|
1
|
-
import { TlaSyntaxError } from "../../errors";
|
|
2
1
|
import type { DecideOptions, Verdict } from "../verdict";
|
|
3
2
|
import { getSatisfiability, type BinaryKind, type PtlFormula } from "./tableau";
|
|
4
3
|
|
|
@@ -39,90 +38,71 @@ const RESERVED = /^(skolem|hidden|constant|NV_V\w*|NVV\w*)$/;
|
|
|
39
38
|
|
|
40
39
|
const MAX_LS4_IDENTIFIER = 31;
|
|
41
40
|
|
|
42
|
-
|
|
41
|
+
// ptl_to_trp and LS4 reach no verdict on text that this reads as undefined.
|
|
42
|
+
const parseLs4 = (text: string): PtlFormula | undefined => {
|
|
43
43
|
const tokens = text.replace(/;.*/g, "").match(/<=>|<->|=>|->|[A-Za-z]\w*|\S/g) ?? [];
|
|
44
44
|
let position = 0;
|
|
45
|
-
const
|
|
46
|
-
|
|
47
|
-
};
|
|
48
|
-
const peek = () => tokens[position] ?? "";
|
|
49
|
-
const take = (expected?: string) => {
|
|
50
|
-
const token = tokens[position++];
|
|
51
|
-
if (token === undefined || (expected !== undefined && token !== expected))
|
|
52
|
-
return reject(`expected ${expected ?? "a formula"}, found ${token ?? "the end"}`);
|
|
53
|
-
return token;
|
|
54
|
-
};
|
|
55
|
-
const checkIdentifier = (token: string) => {
|
|
56
|
-
if (!/^[A-Za-z]/.test(token) || KEYWORDS.has(token))
|
|
57
|
-
reject(`expected an identifier, found ${token}`);
|
|
58
|
-
if (RESERVED.test(token)) reject(`${token} is reserved`);
|
|
59
|
-
return token;
|
|
60
|
-
};
|
|
61
|
-
const takeIdentifier = () => checkIdentifier(take());
|
|
45
|
+
const isIdentifier = (token: string | undefined): token is string =>
|
|
46
|
+
token !== undefined && /^[A-Za-z]/.test(token) && !KEYWORDS.has(token) && !RESERVED.test(token);
|
|
62
47
|
const takeList = () => {
|
|
63
|
-
const items = [
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
48
|
+
const items: string[] = [];
|
|
49
|
+
for (;;) {
|
|
50
|
+
const token = tokens[position++];
|
|
51
|
+
if (!isIdentifier(token)) return undefined;
|
|
52
|
+
items.push(token);
|
|
53
|
+
if (tokens[position] !== ",") return items;
|
|
54
|
+
position += 1;
|
|
67
55
|
}
|
|
68
|
-
return items;
|
|
69
56
|
};
|
|
70
|
-
const parsePrefix = (): PtlFormula => {
|
|
71
|
-
const token =
|
|
57
|
+
const parsePrefix = (): PtlFormula | undefined => {
|
|
58
|
+
const token = tokens[position++];
|
|
59
|
+
if (token === undefined) return undefined;
|
|
72
60
|
const prefix = PREFIX_OPERATORS.get(token);
|
|
73
61
|
if (prefix !== undefined) {
|
|
74
62
|
const body = parsePrefix();
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
: { kind: prefix, body };
|
|
63
|
+
// ptl_to_trp does not translate the past operators.
|
|
64
|
+
return body === undefined || prefix === "Past" ? undefined : { kind: prefix, body };
|
|
78
65
|
}
|
|
79
66
|
if (token === "!" || token === "?") {
|
|
80
|
-
|
|
81
|
-
// foyacc.mly checks only that the last variable of the list is uppercase.
|
|
67
|
+
if (tokens[position++] !== "[") return undefined;
|
|
82
68
|
const variables = takeList();
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
69
|
+
// foyacc.mly checks only that the last variable of the list is uppercase.
|
|
70
|
+
return variables !== undefined &&
|
|
71
|
+
/^[A-Z]/.test(variables[variables.length - 1]) &&
|
|
72
|
+
tokens[position++] === "]"
|
|
73
|
+
? parsePrefix()
|
|
74
|
+
: undefined;
|
|
87
75
|
}
|
|
88
76
|
if (token === "(") {
|
|
89
77
|
const inner = parseBinary(0);
|
|
90
|
-
|
|
91
|
-
return inner;
|
|
78
|
+
return tokens[position++] === ")" ? inner : undefined;
|
|
92
79
|
}
|
|
93
80
|
if (token === "True" || token === "False") return { kind: "Constant", value: token === "True" };
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
take(")");
|
|
99
|
-
reject(`LS4 does not read the predicate ${name} with arguments`);
|
|
100
|
-
}
|
|
101
|
-
if (name.length > MAX_LS4_IDENTIFIER) reject(`the identifier ${name} is too long`);
|
|
102
|
-
return { kind: "Atom", name };
|
|
81
|
+
// LS4 reads no predicate with arguments and no identifier longer than 31 characters.
|
|
82
|
+
return isIdentifier(token) && tokens[position] !== "(" && token.length <= MAX_LS4_IDENTIFIER
|
|
83
|
+
? { kind: "Atom", name: token }
|
|
84
|
+
: undefined;
|
|
103
85
|
};
|
|
104
|
-
const parseOperators = (level: number, left: PtlFormula): PtlFormula => {
|
|
105
|
-
const kind = BINARY_LEVELS[level].get(
|
|
106
|
-
if (kind === undefined) return left;
|
|
107
|
-
|
|
108
|
-
|
|
86
|
+
const parseOperators = (level: number, left: PtlFormula | undefined): PtlFormula | undefined => {
|
|
87
|
+
const kind = BINARY_LEVELS[level].get(tokens[position] ?? "");
|
|
88
|
+
if (left === undefined || kind === undefined) return left;
|
|
89
|
+
position += 1;
|
|
90
|
+
const right = parseBinary(level + 1);
|
|
91
|
+
return right === undefined ? undefined : parseOperators(level, { kind, left, right });
|
|
109
92
|
};
|
|
110
|
-
const parseBinary = (level: number): PtlFormula =>
|
|
93
|
+
const parseBinary = (level: number): PtlFormula | undefined =>
|
|
111
94
|
level === BINARY_LEVELS.length ? parsePrefix() : parseOperators(level, parseBinary(level + 1));
|
|
112
95
|
const formula = parseBinary(0);
|
|
113
|
-
|
|
114
|
-
return formula;
|
|
96
|
+
return position < tokens.length ? undefined : formula;
|
|
115
97
|
};
|
|
116
98
|
|
|
117
99
|
export const decidePtl = (text: string, options: DecideOptions): Verdict => {
|
|
118
100
|
const deadline = performance.now() + options.timeLimitMs;
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
throw error;
|
|
127
|
-
}
|
|
101
|
+
const formula = parseLs4(text);
|
|
102
|
+
return formula === undefined
|
|
103
|
+
? "unknown"
|
|
104
|
+
: getSatisfiability(
|
|
105
|
+
formula,
|
|
106
|
+
() => options.signal?.aborted === true || performance.now() > deadline,
|
|
107
|
+
);
|
|
128
108
|
};
|