tla-ts 0.0.3 → 0.0.4-dev.2a873ee
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +46 -115
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +194 -8
- package/dist/index.d.ts +194 -8
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +996 -0
- package/dist/prove.js +996 -0
- package/dist/run-cli.cjs +37 -20
- package/dist/run-cli.js +37 -20
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +1387 -18
- package/dist/transfer.js +1387 -18
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +24 -11
- package/src/ast.ts +149 -8
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1540 -235
- package/src/cli-options.ts +12 -6
- package/src/cli.ts +8 -1
- package/src/codegen.ts +98 -39
- package/src/config.ts +254 -181
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +540 -140
- package/src/errors.ts +284 -4
- package/src/evaluate.ts +1043 -293
- package/src/exit-codes.ts +22 -43
- package/src/fingerprints.ts +46 -11
- package/src/index.ts +11 -0
- package/src/instances.ts +19 -16
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +191 -45
- package/src/lexer.ts +127 -30
- package/src/live-check.ts +867 -0
- package/src/liveness.ts +218 -572
- package/src/{obligation-action.ts → obligations/action.ts} +247 -69
- package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
- package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
- package/src/{obligations.ts → obligations/index.ts} +32 -16
- package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
- package/src/{obligation-module.ts → obligations/module.ts} +113 -121
- package/src/obligations/pickle.ts +98 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/{obligation-source.ts → obligations/source.ts} +156 -99
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +169 -224
- package/src/parallel.ts +140 -81
- package/src/parser.ts +456 -147
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/prove/decide-pool.ts +95 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/first-order.ts +78 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +446 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +546 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +433 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +331 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +330 -0
- package/src/prove/isabelle/pure/name.ts +98 -0
- package/src/prove/isabelle/pure/net.ts +215 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +631 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +133 -0
- package/src/prove/isabelle/pure/simplifier.ts +106 -0
- package/src/prove/isabelle/pure/table.ts +201 -0
- package/src/prove/isabelle/pure/tactic.ts +168 -0
- package/src/prove/isabelle/pure/tactical.ts +264 -0
- package/src/prove/isabelle/pure/term-ord.ts +105 -0
- package/src/prove/isabelle/pure/term.ts +688 -0
- package/src/prove/isabelle/pure/thm.ts +783 -0
- package/src/prove/isabelle/pure/type.ts +121 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +508 -0
- package/src/prove/prep/defs.ts +33 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +529 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +22 -0
- package/src/prove/prove.ts +498 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +255 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +209 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +164 -0
- package/src/prove/smt/extensionality.ts +65 -0
- package/src/prove/smt/flatten.ts +112 -0
- package/src/prove/smt/format.ts +154 -0
- package/src/prove/smt/instances.ts +181 -0
- package/src/prove/smt/rewrite.ts +772 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +91 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +96 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +18 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +379 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +162 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1481 -426
- package/src/run-cli.ts +1483 -212
- package/src/runtime.ts +19 -1
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3128 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +356 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +42 -11
- package/src/standard-modules.ts +203 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +180 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +241 -110
- package/src/symmetry.ts +194 -54
- package/src/tableau.ts +54 -25
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-ext.ts +42 -29
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +52 -43
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +78 -10
- package/src/tlc-random.ts +84 -33
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +19 -0
- package/src/transfer.ts +15 -3
- package/src/values.ts +787 -190
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
Copyright (c) 2008 INRIA and Microsoft Corporation
|
|
2
|
+
Copyright (c) 2023 Linux Foundation
|
|
3
|
+
|
|
4
|
+
Redistribution and use in source and binary forms, with or without
|
|
5
|
+
modification, are permitted provided that the following conditions are
|
|
6
|
+
met:
|
|
7
|
+
|
|
8
|
+
* Redistributions of source code must retain the above copyright
|
|
9
|
+
notice, this list of conditions and the following disclaimer.
|
|
10
|
+
|
|
11
|
+
* Redistributions in binary form must reproduce the above copyright
|
|
12
|
+
notice, this list of conditions and the following disclaimer in
|
|
13
|
+
the documentation and/or other materials provided with the
|
|
14
|
+
distribution.
|
|
15
|
+
|
|
16
|
+
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
17
|
+
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
18
|
+
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
19
|
+
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
20
|
+
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
21
|
+
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
22
|
+
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
23
|
+
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
24
|
+
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
25
|
+
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
26
|
+
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
// Decides a theory tlapm writes for Isabelle, as tlapm's Isabelle backend runs it: use_thy on the
|
|
2
|
+
// heap of Isabelle/TLA+ succeeds or fails.
|
|
3
|
+
|
|
4
|
+
import { TlaIsabelleError } from "../../errors";
|
|
5
|
+
import type { DecideOptions, Verdict } from "../verdict";
|
|
6
|
+
import { parseProofText, terminalProof } from "./isar/method";
|
|
7
|
+
import { getFacts, initGoal } from "./isar/proof";
|
|
8
|
+
import { readStatement } from "./isar/statement";
|
|
9
|
+
import { parseTheory } from "./isar/theory";
|
|
10
|
+
import { protect } from "./pure/logic";
|
|
11
|
+
import { seqHead } from "./pure/seq";
|
|
12
|
+
import { aconv } from "./pure/term";
|
|
13
|
+
import { getProofContext } from "./tla/context";
|
|
14
|
+
import { loadLogic } from "./tla/logic";
|
|
15
|
+
|
|
16
|
+
// V8's error when a recursion runs out of stack. Poly/ML grows its stack instead, until the
|
|
17
|
+
// recursion ends or Isabelle breaks down for lack of memory, which tlapm counts as a failure.
|
|
18
|
+
const isStackOverflow = (error: unknown) =>
|
|
19
|
+
error instanceof RangeError && error.message === "Maximum call stack size exceeded";
|
|
20
|
+
|
|
21
|
+
export const decideIsabelle = (text: string, options: DecideOptions): Exclude<Verdict, "sat"> => {
|
|
22
|
+
const limits = { deadline: Date.now() + options.timeLimitMs, signal: options.signal };
|
|
23
|
+
try {
|
|
24
|
+
const theory = parseTheory(text);
|
|
25
|
+
const logic = loadLogic();
|
|
26
|
+
const statement = readStatement(logic, theory);
|
|
27
|
+
const facts = theory.isUsingAssms ? getFacts(limits, statement) : [];
|
|
28
|
+
const result = seqHead(
|
|
29
|
+
terminalProof(
|
|
30
|
+
getProofContext(logic, limits),
|
|
31
|
+
parseProofText(theory.method),
|
|
32
|
+
facts,
|
|
33
|
+
initGoal(statement),
|
|
34
|
+
),
|
|
35
|
+
);
|
|
36
|
+
// Proof.conclude_goal: the theorem must be the statement, from its assumptions only.
|
|
37
|
+
return result !== undefined &&
|
|
38
|
+
result.tpairs.length === 0 &&
|
|
39
|
+
aconv(result.prop, protect(statement.conclusion)) &&
|
|
40
|
+
result.hyps.every((hyp) => statement.assumptions.some((assumption) => aconv(hyp, assumption)))
|
|
41
|
+
? "unsat"
|
|
42
|
+
: "unknown";
|
|
43
|
+
} catch (error) {
|
|
44
|
+
if (error instanceof TlaIsabelleError || isStackOverflow(error)) return "unknown";
|
|
45
|
+
throw error;
|
|
46
|
+
}
|
|
47
|
+
};
|
|
@@ -0,0 +1,446 @@
|
|
|
1
|
+
// Ported from tlapm's src/backend/isabelle.ml (BSD licensed, see LICENSE-tlapm).
|
|
2
|
+
// An obligation as the Isabelle/TLA+ theory tlapm writes for Isabelle to prove with a tactic.
|
|
3
|
+
|
|
4
|
+
import { TlapmBugError, TlaProverError, TlaUnsupportedError } from "../../errors";
|
|
5
|
+
import { createContext, getBoundName, popNames, pushName } from "../../obligations/ctx";
|
|
6
|
+
import type { Bound, Builtin, Expr, Sequent } from "../../obligations/expression";
|
|
7
|
+
import { pickle } from "../../obligations/pickle";
|
|
8
|
+
import { getUnprintableError, printFact, splitFirstBound } from "../first-order";
|
|
9
|
+
|
|
10
|
+
const cook = (name: string) => `is${pickle(name)}`;
|
|
11
|
+
|
|
12
|
+
const ATOMS: Partial<Record<Builtin, string>> = {
|
|
13
|
+
TRUE: "TRUE",
|
|
14
|
+
FALSE: "FALSE",
|
|
15
|
+
STRING: "STRING",
|
|
16
|
+
BOOLEAN: "BOOLEAN",
|
|
17
|
+
Nat: "Nat",
|
|
18
|
+
Int: "Int",
|
|
19
|
+
Real: cook("Real"),
|
|
20
|
+
Infinity: cook("Infinity"),
|
|
21
|
+
Any: "Any",
|
|
22
|
+
};
|
|
23
|
+
|
|
24
|
+
const UNARY: Partial<Record<Builtin, string>> = {
|
|
25
|
+
Neg: "~",
|
|
26
|
+
DOMAIN: "DOMAIN",
|
|
27
|
+
SUBSET: "SUBSET",
|
|
28
|
+
UNION: "UNION",
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
const BINARY: Partial<Record<Builtin, string>> = {
|
|
32
|
+
Implies: "\\<Rightarrow>",
|
|
33
|
+
Equiv: "\\<Leftrightarrow>",
|
|
34
|
+
Conj: "\\<and>",
|
|
35
|
+
Disj: "\\<or>",
|
|
36
|
+
Eq: "=",
|
|
37
|
+
Neq: "\\<noteq>",
|
|
38
|
+
Subseteq: "\\<subseteq>",
|
|
39
|
+
Mem: "\\<in>",
|
|
40
|
+
Notmem: "\\<notin>",
|
|
41
|
+
Setminus: "\\\\",
|
|
42
|
+
Cap: "\\<inter>",
|
|
43
|
+
Cup: "\\<union>",
|
|
44
|
+
OneArg: ":>",
|
|
45
|
+
Extend: "@@",
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
const NONFIX: Partial<Record<Builtin, [string, number]>> = {
|
|
49
|
+
Plus: ["addint", 2],
|
|
50
|
+
Minus: ["subint", 2],
|
|
51
|
+
Uminus: ["minus", 1],
|
|
52
|
+
Times: ["mult", 2],
|
|
53
|
+
Ratio: [cook("/"), 2],
|
|
54
|
+
Quotient: [cook("\\div"), 2],
|
|
55
|
+
Remainder: [cook("%"), 2],
|
|
56
|
+
Exp: [cook("^"), 2],
|
|
57
|
+
Lteq: ["leq", 2],
|
|
58
|
+
Lt: ["less", 2],
|
|
59
|
+
Gteq: ["geq", 2],
|
|
60
|
+
Gt: ["greater", 2],
|
|
61
|
+
Range: ["intvl", 2],
|
|
62
|
+
Seq: ["Seq", 1],
|
|
63
|
+
Len: ["Len", 1],
|
|
64
|
+
BSeq: ["BSeq", 1],
|
|
65
|
+
Cat: [cook("\\circ"), 2],
|
|
66
|
+
Append: ["Append", 2],
|
|
67
|
+
Head: ["Head", 1],
|
|
68
|
+
Tail: ["Tail", 1],
|
|
69
|
+
SubSeq: ["SubSeq", 3],
|
|
70
|
+
SelectSeq: ["SelectSeq", 2],
|
|
71
|
+
Print: ["Print", 2],
|
|
72
|
+
PrintT: ["PrintT", 1],
|
|
73
|
+
Assert: ["Assert", 2],
|
|
74
|
+
JavaTime: ["JavaTime", 0],
|
|
75
|
+
TLCGet: ["TLCGet", 1],
|
|
76
|
+
TLCSet: ["TLCSet", 2],
|
|
77
|
+
Permutations: ["Permutations", 1],
|
|
78
|
+
SortSeq: ["SortSeq", 2],
|
|
79
|
+
RandomElement: ["RandomElement", 1],
|
|
80
|
+
ToString: ["ToString", 1],
|
|
81
|
+
};
|
|
82
|
+
|
|
83
|
+
// thy_header's tdoms_table: the operators the theory declares, with their arities.
|
|
84
|
+
const DECLARED: [string, number][] = [
|
|
85
|
+
["Real", 0],
|
|
86
|
+
["/", 2],
|
|
87
|
+
["\\div", 2],
|
|
88
|
+
["%", 2],
|
|
89
|
+
["..", 2],
|
|
90
|
+
["Infinity", 0],
|
|
91
|
+
["[]", 1],
|
|
92
|
+
["<>", 1],
|
|
93
|
+
];
|
|
94
|
+
|
|
95
|
+
const HEADER = [
|
|
96
|
+
"consts",
|
|
97
|
+
...DECLARED.map(
|
|
98
|
+
(declared) =>
|
|
99
|
+
` "${cook(declared[0])}" :: ${declared[1] === 0 ? "c" : `"[${Array(declared[1]).fill("c").join(",")}] => c"`}`,
|
|
100
|
+
),
|
|
101
|
+
"",
|
|
102
|
+
].join("\n");
|
|
103
|
+
|
|
104
|
+
const getSuccessors = (integer: string) => {
|
|
105
|
+
const count = Number.parseInt(integer, 10);
|
|
106
|
+
return `${"succ[".repeat(count)}0${"]".repeat(count)}`;
|
|
107
|
+
};
|
|
108
|
+
|
|
109
|
+
// thy_header.
|
|
110
|
+
const getTheoryHeader = (name: string, isVerbose: boolean) => [
|
|
111
|
+
"(* automatically generated -- do not edit manually *)",
|
|
112
|
+
`theory ${name} imports Constant Zenon begin`,
|
|
113
|
+
...(isVerbose ? ['ML_command \\<open> writeln ("*** TLAPS PARSED\\n"); \\<close>'] : []),
|
|
114
|
+
HEADER,
|
|
115
|
+
];
|
|
116
|
+
|
|
117
|
+
// pp_print_expr on an obligation after Backend.Prep has shipped it.
|
|
118
|
+
const printLemma = (sequent: Sequent) => {
|
|
119
|
+
const context = createContext();
|
|
120
|
+
const adjoin = (name: string) => pushName(context, pickle(name));
|
|
121
|
+
const bump = () => pushName(context, "");
|
|
122
|
+
|
|
123
|
+
// A binder's name binds in what prints inside it.
|
|
124
|
+
const withBound = (name: string, print: (bound: string) => string) => {
|
|
125
|
+
const doc = print(adjoin(name));
|
|
126
|
+
popNames(context, 1);
|
|
127
|
+
return doc;
|
|
128
|
+
};
|
|
129
|
+
|
|
130
|
+
// pp_print_expr: every expression, apart from the obligation's sequent, prints in parentheses.
|
|
131
|
+
const printExpr = (expression: Expr) => `(${formatExpr(expression)})`;
|
|
132
|
+
const delimited = (args: Expr[]) => args.map(printExpr).join(", ");
|
|
133
|
+
const nonfix = (name: string, args: Expr[]) => `(${name} (${delimited(args)}))`;
|
|
134
|
+
|
|
135
|
+
const printInternal = (builtin: Builtin, args: Expr[]): string => {
|
|
136
|
+
const atom = ATOMS[builtin];
|
|
137
|
+
if (atom !== undefined && args.length === 0) return atom;
|
|
138
|
+
const unary = UNARY[builtin];
|
|
139
|
+
if (unary !== undefined && args.length === 1) return `(${unary} ${printExpr(args[0])})`;
|
|
140
|
+
const binary = BINARY[builtin];
|
|
141
|
+
if (binary !== undefined && args.length === 2)
|
|
142
|
+
return `(${printExpr(args[0])} ${binary} ${printExpr(args[1])})`;
|
|
143
|
+
const operator = NONFIX[builtin];
|
|
144
|
+
if (operator && operator[1] === args.length) return nonfix(operator[0], args);
|
|
145
|
+
if (builtin === "Unprimable" && args.length === 1) return printExpr(args[0]);
|
|
146
|
+
// tlapm prints an irregular expression as the hash of its TLA+ text, but never makes one.
|
|
147
|
+
if (builtin === "Irregular" && args.length === 1) throw new TlaUnsupportedError("Irregular");
|
|
148
|
+
throw getUnprintableError(builtin, args.length, "Backend.Isabelle.pp_apply");
|
|
149
|
+
};
|
|
150
|
+
|
|
151
|
+
const printApply = (operator: Expr, args: Expr[]): string => {
|
|
152
|
+
switch (operator.kind) {
|
|
153
|
+
case "Ix": {
|
|
154
|
+
const name = getBoundName(context, operator.index);
|
|
155
|
+
if (operator.index <= 0 || name === undefined) throw new TlapmBugError();
|
|
156
|
+
return args.length === 0 ? name : `(${name} (${delimited(args)}))`;
|
|
157
|
+
}
|
|
158
|
+
case "Opaque": {
|
|
159
|
+
const name = pickle(operator.name);
|
|
160
|
+
return args.length === 0 ? `(${name} :: c)` : `(${name} (${delimited(args)}) :: c)`;
|
|
161
|
+
}
|
|
162
|
+
case "Internal":
|
|
163
|
+
return printInternal(operator.builtin, args);
|
|
164
|
+
// tlapm prints a lambda without the arguments it's applied to.
|
|
165
|
+
case "Lambda": {
|
|
166
|
+
const names = operator.params.map((param) => `${adjoin(param.name)} `).join("");
|
|
167
|
+
const doc = `\\<lambda> ${names}. ${printExpr(operator.body)}`;
|
|
168
|
+
popNames(context, operator.params.length);
|
|
169
|
+
return doc;
|
|
170
|
+
}
|
|
171
|
+
default:
|
|
172
|
+
throw new TlapmBugError();
|
|
173
|
+
}
|
|
174
|
+
};
|
|
175
|
+
|
|
176
|
+
const printQuant = (quantifier: "Forall" | "Exists", bounds: Bound[], body: Expr): string => {
|
|
177
|
+
if (bounds.length === 0) return formatExpr(body);
|
|
178
|
+
const split = splitFirstBound(quantifier, bounds, body);
|
|
179
|
+
const symbol = quantifier === "Forall" ? "\\<forall>" : "\\<exists>";
|
|
180
|
+
if (split.first.domain.kind === "NoDomain")
|
|
181
|
+
return withBound(split.first.name, (name) => `${symbol}${name} : ${printExpr(split.inner)}`);
|
|
182
|
+
if (split.first.domain.kind !== "Domain") throw new TlapmBugError();
|
|
183
|
+
const domain = printExpr(split.first.domain.expression);
|
|
184
|
+
return withBound(
|
|
185
|
+
split.first.name,
|
|
186
|
+
(name) => `${symbol} ${name} \\<in> ${domain} : ${printExpr(split.inner)}`,
|
|
187
|
+
);
|
|
188
|
+
};
|
|
189
|
+
|
|
190
|
+
// pp_print_sequent_inner: a sequent inside an expression, as a meta-level implication.
|
|
191
|
+
const printNestedSequent = (sequent: Sequent): string => {
|
|
192
|
+
if (sequent.context.length === 0) return printExpr(sequent.active);
|
|
193
|
+
const hyp = sequent.context[0];
|
|
194
|
+
const printRest = () =>
|
|
195
|
+
printNestedSequent({ context: sequent.context.slice(1), active: sequent.active });
|
|
196
|
+
switch (hyp.kind) {
|
|
197
|
+
case "Flex":
|
|
198
|
+
return withBound(hyp.name, (name) => `(\\<And> ${name} ${name}'.${printRest()})`);
|
|
199
|
+
case "Fresh": {
|
|
200
|
+
if (hyp.domain && hyp.domainVisibility === "Visible") {
|
|
201
|
+
const domain = printExpr(hyp.domain);
|
|
202
|
+
return withBound(
|
|
203
|
+
hyp.name,
|
|
204
|
+
(name) =>
|
|
205
|
+
`(\\<And> ${name} :: c. ${name} \\<in> ${domain} \\<Longrightarrow> ${printRest()})`,
|
|
206
|
+
);
|
|
207
|
+
}
|
|
208
|
+
const shape = `${"c => ".repeat(hyp.shape)}c`;
|
|
209
|
+
return withBound(hyp.name, (name) => `(\\<And> ${name} :: ${shape}. ${printRest()})`);
|
|
210
|
+
}
|
|
211
|
+
case "Fact": {
|
|
212
|
+
const fact = hyp.visibility === "Visible" ? printExpr(hyp.expression) : undefined;
|
|
213
|
+
bump();
|
|
214
|
+
const doc = fact ? `(${fact} \\<Longrightarrow> ${printRest()})` : printRest();
|
|
215
|
+
popNames(context, 1);
|
|
216
|
+
return doc;
|
|
217
|
+
}
|
|
218
|
+
case "Defn":
|
|
219
|
+
throw new TlaUnsupportedError("Inner definition");
|
|
220
|
+
}
|
|
221
|
+
};
|
|
222
|
+
|
|
223
|
+
const formatExpr = (expression: Expr): string => {
|
|
224
|
+
switch (expression.kind) {
|
|
225
|
+
case "Ix":
|
|
226
|
+
case "Internal":
|
|
227
|
+
case "Opaque":
|
|
228
|
+
case "Lambda":
|
|
229
|
+
return printApply(expression, []);
|
|
230
|
+
case "Apply":
|
|
231
|
+
return printApply(expression.operator, expression.args);
|
|
232
|
+
case "Bang":
|
|
233
|
+
throw new TlaProverError("Backend.Isabelle.module");
|
|
234
|
+
case "Sequent":
|
|
235
|
+
return printNestedSequent(expression.sequent);
|
|
236
|
+
case "With":
|
|
237
|
+
case "Parens":
|
|
238
|
+
return formatExpr(expression.expression);
|
|
239
|
+
case "Let":
|
|
240
|
+
throw new TlaUnsupportedError("LET");
|
|
241
|
+
case "List":
|
|
242
|
+
if (expression.bullet === "Refs" && expression.items.length === 0) return "TRUE";
|
|
243
|
+
if (expression.bullet === "Refs" && expression.items.length === 1)
|
|
244
|
+
return formatExpr(expression.items[0]);
|
|
245
|
+
return expression.items.map(printExpr).join(expression.bullet === "Or" ? " | " : " & ");
|
|
246
|
+
case "If":
|
|
247
|
+
return `cond(${printExpr(expression.condition)}, ${printExpr(expression.consequent)}, ${printExpr(expression.alternative)})`;
|
|
248
|
+
case "Quant":
|
|
249
|
+
return printQuant(expression.quantifier, expression.bounds, expression.body);
|
|
250
|
+
case "Tquant":
|
|
251
|
+
throw new TlaUnsupportedError(expression.quantifier === "Forall" ? "\\\\AA" : "\\\\EE");
|
|
252
|
+
case "Choose": {
|
|
253
|
+
if (!expression.domain)
|
|
254
|
+
return withBound(
|
|
255
|
+
expression.name,
|
|
256
|
+
(name) => `Choice(%${name}. ${printExpr(expression.body)})`,
|
|
257
|
+
);
|
|
258
|
+
const domain = printExpr(expression.domain);
|
|
259
|
+
return withBound(
|
|
260
|
+
expression.name,
|
|
261
|
+
(name) => `bChoice(${domain}, %${name}. ${printExpr(expression.body)})`,
|
|
262
|
+
);
|
|
263
|
+
}
|
|
264
|
+
case "SetSt": {
|
|
265
|
+
const domain = printExpr(expression.domain);
|
|
266
|
+
return withBound(
|
|
267
|
+
expression.name,
|
|
268
|
+
(name) => `subsetOf(${domain}, %${name}. ${printExpr(expression.body)})`,
|
|
269
|
+
);
|
|
270
|
+
}
|
|
271
|
+
case "SetOf": {
|
|
272
|
+
if (expression.bounds.length === 0) throw new TlapmBugError();
|
|
273
|
+
const bound = expression.bounds[0];
|
|
274
|
+
if (expression.bounds.length !== 1 || bound.domain.kind !== "Domain")
|
|
275
|
+
throw new TlaUnsupportedError("SetOf (multiple declared constants)");
|
|
276
|
+
const domain = printExpr(bound.domain.expression);
|
|
277
|
+
return withBound(
|
|
278
|
+
bound.name,
|
|
279
|
+
(name) => `setOfAll(${domain}, %${name}. ${printExpr(expression.element)})`,
|
|
280
|
+
);
|
|
281
|
+
}
|
|
282
|
+
case "SetEnum":
|
|
283
|
+
return `{${delimited(expression.elements)}}`;
|
|
284
|
+
case "Fcn": {
|
|
285
|
+
const bound = expression.bounds[0];
|
|
286
|
+
if (expression.bounds.length !== 1)
|
|
287
|
+
throw new TlaUnsupportedError("function (multiple declared constants)");
|
|
288
|
+
if (bound.domain.kind === "Ditto") throw new TlapmBugError();
|
|
289
|
+
const domain =
|
|
290
|
+
bound.domain.kind === "Domain" ? printExpr(bound.domain.expression) : undefined;
|
|
291
|
+
return withBound(bound.name, (name) => {
|
|
292
|
+
const printed = domain === undefined ? name : ` ${name} \\<in> ${domain} `;
|
|
293
|
+
return `[${printed} \\<mapsto> ${printExpr(expression.body)}]`;
|
|
294
|
+
});
|
|
295
|
+
}
|
|
296
|
+
case "FcnApp": {
|
|
297
|
+
const fcn = printExpr(expression.function);
|
|
298
|
+
return expression.args.length === 1
|
|
299
|
+
? `fapply (${fcn}, ${printExpr(expression.args[0])})`
|
|
300
|
+
: `fapply (${fcn}, <<${delimited(expression.args)}>>)`;
|
|
301
|
+
}
|
|
302
|
+
case "Arrow":
|
|
303
|
+
return `[${printExpr(expression.domain)} \\<rightarrow> ${printExpr(expression.range)}]`;
|
|
304
|
+
case "Rect":
|
|
305
|
+
return `[${expression.fields.map((field) => `''${field.name}'' : ${printExpr(field.value)}`).join(", ")}]`;
|
|
306
|
+
case "Record":
|
|
307
|
+
return `(${expression.fields.map((field) => `(''${field.name}'' :> ${printExpr(field.value)})`).join(" @@ ")})`;
|
|
308
|
+
case "Except": {
|
|
309
|
+
const specs = expression.specs.map((spec) => {
|
|
310
|
+
const trail = spec.trail
|
|
311
|
+
.map((point) =>
|
|
312
|
+
point.kind === "Dot" ? `[''${point.field}'']` : `[${printExpr(point.expression)}]`,
|
|
313
|
+
)
|
|
314
|
+
.join("");
|
|
315
|
+
return `!${trail} = ${printExpr(spec.value)}`;
|
|
316
|
+
});
|
|
317
|
+
return `[${printExpr(expression.function)} EXCEPT ${specs.join(", ")}]`;
|
|
318
|
+
}
|
|
319
|
+
case "Dot":
|
|
320
|
+
return `fapply (${printExpr(expression.expression)}, (''${expression.field}''))`;
|
|
321
|
+
case "Tuple":
|
|
322
|
+
return `<<${delimited(expression.elements)}>>`;
|
|
323
|
+
case "Product":
|
|
324
|
+
return expression.factors.length === 2
|
|
325
|
+
? `(${printExpr(expression.factors[0])} \\<times> ${printExpr(expression.factors[1])})`
|
|
326
|
+
: `Product(\\<langle>${delimited(expression.factors)}\\<rangle>)`;
|
|
327
|
+
case "Sub":
|
|
328
|
+
case "Tsub": {
|
|
329
|
+
const suffix = expression.kind === "Sub" ? "sub" : "tsub";
|
|
330
|
+
const name = expression.modal === "Box" ? cook(`a'box'${suffix}`) : `a'dia'${suffix}`;
|
|
331
|
+
return `${name}(${printExpr(expression.action)},${printExpr(expression.subscript)})`;
|
|
332
|
+
}
|
|
333
|
+
case "Fair":
|
|
334
|
+
return `${cook(expression.fairness === "Weak" ? "a'wf" : "a'sf")}(${printExpr(expression.subscript)},${printExpr(expression.action)})`;
|
|
335
|
+
case "Case": {
|
|
336
|
+
const conditions = delimited(expression.arms.map((arm) => arm.condition));
|
|
337
|
+
const bodies = delimited(expression.arms.map((arm) => arm.body));
|
|
338
|
+
return expression.other
|
|
339
|
+
? `CaseOther(<<${conditions}>>,<<${bodies}>>,${printExpr(expression.other)})`
|
|
340
|
+
: `Case(<<${conditions}>>,<<${bodies}>>)`;
|
|
341
|
+
}
|
|
342
|
+
case "String":
|
|
343
|
+
return `''${expression.value}''`;
|
|
344
|
+
case "Num":
|
|
345
|
+
if (expression.fraction !== "") throw new TlaUnsupportedError("real constants");
|
|
346
|
+
return `(${getSuccessors(expression.integer)})`;
|
|
347
|
+
case "At":
|
|
348
|
+
throw new TlapmBugError();
|
|
349
|
+
}
|
|
350
|
+
};
|
|
351
|
+
|
|
352
|
+
// pp_print_sequent_outer: the obligation's sequent as the lines of a lemma's fixes, assumes and
|
|
353
|
+
// shows. A pragma's definition ends it with an empty line in place of the goal.
|
|
354
|
+
const printSequent = (sequent: Sequent) => {
|
|
355
|
+
const lines: string[] = [];
|
|
356
|
+
for (const hyp of sequent.context) {
|
|
357
|
+
switch (hyp.kind) {
|
|
358
|
+
case "Flex": {
|
|
359
|
+
const name = adjoin(hyp.name);
|
|
360
|
+
lines.push(`fixes ${name} ${name}'`);
|
|
361
|
+
break;
|
|
362
|
+
}
|
|
363
|
+
case "Fresh": {
|
|
364
|
+
const domain =
|
|
365
|
+
hyp.domain && hyp.domainVisibility === "Visible" ? printExpr(hyp.domain) : undefined;
|
|
366
|
+
const name = adjoin(hyp.name);
|
|
367
|
+
lines.push(`fixes ${name}`);
|
|
368
|
+
if (domain === undefined) break;
|
|
369
|
+
lines.push(`assumes ${name}_in : "(${name} \\<in> ${domain})"`);
|
|
370
|
+
break;
|
|
371
|
+
}
|
|
372
|
+
case "Fact": {
|
|
373
|
+
const count = context.stack.length;
|
|
374
|
+
const fact =
|
|
375
|
+
hyp.visibility === "Visible"
|
|
376
|
+
? printFact(context, () => printExpr(hyp.expression))
|
|
377
|
+
: undefined;
|
|
378
|
+
bump();
|
|
379
|
+
if (fact instanceof TlaUnsupportedError) {
|
|
380
|
+
lines.push(`(* omitted temporal assumption : ${fact.message} *)`);
|
|
381
|
+
break;
|
|
382
|
+
}
|
|
383
|
+
if (fact === undefined) break;
|
|
384
|
+
lines.push(`assumes v'${count}: "${fact}"`);
|
|
385
|
+
break;
|
|
386
|
+
}
|
|
387
|
+
case "Defn":
|
|
388
|
+
if (hyp.definition.kind === "Bpragma") return [...lines, ""];
|
|
389
|
+
lines.push(`(* usable definition ${hyp.definition.name} suppressed *)`);
|
|
390
|
+
adjoin(hyp.definition.name);
|
|
391
|
+
break;
|
|
392
|
+
}
|
|
393
|
+
}
|
|
394
|
+
return [...lines, `shows "${printExpr(sequent.active)}"`];
|
|
395
|
+
};
|
|
396
|
+
|
|
397
|
+
try {
|
|
398
|
+
const lines = printSequent(sequent);
|
|
399
|
+
return {
|
|
400
|
+
text: lines.join("\n"),
|
|
401
|
+
isAssumed: lines.some((line) => line.startsWith("assumes ")),
|
|
402
|
+
};
|
|
403
|
+
} catch (error) {
|
|
404
|
+
if (!(error instanceof TlaUnsupportedError)) throw error;
|
|
405
|
+
throw new TlaProverError(`isabelle : unsupported operator ${error.message}`);
|
|
406
|
+
}
|
|
407
|
+
};
|
|
408
|
+
|
|
409
|
+
// thy_temp: the theory tlapm writes for Isabelle to prove obligation id.
|
|
410
|
+
export const encodeIsabelle = (id: number, sequent: Sequent, tactic: string): string => {
|
|
411
|
+
const lemma = printLemma(sequent);
|
|
412
|
+
return [
|
|
413
|
+
...getTheoryHeader(`tlapm_${id}`, false),
|
|
414
|
+
`lemma ob'${id}:`,
|
|
415
|
+
`${lemma.text}(is "PROP ?ob'${id}")`,
|
|
416
|
+
"proof -",
|
|
417
|
+
`show "PROP ?ob'${id}"`,
|
|
418
|
+
`${lemma.isAssumed ? "using assms " : ""}by ${tactic}`,
|
|
419
|
+
"qed",
|
|
420
|
+
"end",
|
|
421
|
+
"",
|
|
422
|
+
].join("\n");
|
|
423
|
+
};
|
|
424
|
+
|
|
425
|
+
interface IsabelleProof {
|
|
426
|
+
id: number;
|
|
427
|
+
sequent: Sequent;
|
|
428
|
+
tactic: string;
|
|
429
|
+
}
|
|
430
|
+
|
|
431
|
+
// Isabelle.thy_init, thy_write and thy_close.
|
|
432
|
+
export const encodeIsabelleTheory = (name: string, proofs: IsabelleProof[]) =>
|
|
433
|
+
[
|
|
434
|
+
...getTheoryHeader(name, true),
|
|
435
|
+
...proofs.flatMap((proof) => [
|
|
436
|
+
`lemma ob'${proof.id}:`,
|
|
437
|
+
`${printLemma(proof.sequent).text}(is "PROP ?ob'${proof.id}")`,
|
|
438
|
+
"proof -",
|
|
439
|
+
`ML_command \\<open> writeln "*** TLAPS ENTER ${proof.id}"; \\<close>`,
|
|
440
|
+
`show "PROP ?ob'${proof.id}"`,
|
|
441
|
+
`using assms by ${proof.tactic}`,
|
|
442
|
+
`ML_command \\<open> writeln "*** TLAPS EXIT ${proof.id}"; \\<close> qed`,
|
|
443
|
+
]),
|
|
444
|
+
"end",
|
|
445
|
+
"",
|
|
446
|
+
].join("\n");
|