From a3e9ecf974d7c8d356b05e6a7a84e1fdb255346a Mon Sep 17 00:00:00 2001 From: c-cube Date: Sat, 7 Oct 2023 02:14:09 +0000 Subject: [PATCH] deploy: 43c8e60790140834f80cd247c35940bea475aa8c --- .../fonts/fira-mono-v14-latin-500.woff2 | Bin 0 -> 16148 bytes .../fonts/fira-mono-v14-latin-regular.woff2 | Bin 0 -> 16284 bytes .../fonts/fira-sans-v17-latin-500.woff2 | Bin 0 -> 24020 bytes .../fonts/fira-sans-v17-latin-500italic.woff2 | Bin 0 -> 24896 bytes .../fonts/fira-sans-v17-latin-700.woff2 | Bin 0 -> 24964 bytes .../fonts/fira-sans-v17-latin-700italic.woff2 | Bin 0 -> 26072 bytes .../fonts/fira-sans-v17-latin-italic.woff2 | Bin 0 -> 24936 bytes .../fonts/fira-sans-v17-latin-regular.woff2 | Bin 0 -> 23880 bytes .../fonts/noticia-text-v15-latin-700.woff2 | Bin 0 -> 21972 bytes .../fonts/noticia-text-v15-latin-italic.woff2 | Bin 0 -> 17356 bytes .../noticia-text-v15-latin-regular.woff2 | Bin 0 -> 22308 bytes dev/odoc.support/highlight.pack.js | 373 +++++++++++++----- dev/odoc.support/odoc.css | 236 ++++++++++- dev/sidekick-base/Sidekick_base/.dummy | 0 .../Sidekick_base/Config/Key/index.html | 2 +- .../Sidekick_base/Config/index.html | 2 +- .../Sidekick_base/Data_ty/Cstor/index.html | 2 +- .../Sidekick_base/Data_ty/Select/index.html | 2 +- .../Sidekick_base/Data_ty/index.html | 2 +- .../Sidekick_base/Form/index.html | 2 +- dev/sidekick-base/Sidekick_base/ID/index.html | 2 +- .../Sidekick_base/LRA_term/Op/index.html | 2 +- .../Sidekick_base/LRA_term/Pred/index.html | 2 +- .../Sidekick_base/LRA_term/View/index.html | 2 +- .../Sidekick_base/LRA_term/index.html | 2 +- .../Sidekick_base/Solver/index.html | 42 +- .../Sidekick_base/Statement/index.html | 2 +- .../Sidekick_base/Term/index.html | 14 +- .../Sidekick_base/Th_bool/index.html | 2 +- .../Sidekick_base/Th_data/index.html | 2 +- .../Sidekick_base/Th_lra/index.html | 2 +- .../Sidekick_base/Th_ty_unin/index.html | 2 +- dev/sidekick-base/Sidekick_base/Ty/index.html | 32 +- .../Sidekick_base/Types_/index.html | 4 +- .../Sidekick_base/Uconst/index.html | 4 +- dev/sidekick-base/Sidekick_base/index.html | 4 +- dev/sidekick-base/Sidekick_smtlib/.dummy | 0 .../Sidekick_smtlib/Check_cc/index.html | 2 +- .../Sidekick_smtlib/Driver/index.html | 18 +- .../Sidekick_smtlib/Model/index.html | 2 +- .../Sidekick_smtlib/Solver/index.html | 2 +- dev/sidekick-base/Sidekick_smtlib/index.html | 2 +- dev/sidekick-base/index.html | 2 +- dev/sidekick-bin/Sidekick_bin_lib/.dummy | 0 .../Sidekick_bin_lib/Dimacs_lexer/index.html | 2 +- .../Sidekick_bin_lib/Dimacs_parser/index.html | 2 +- .../Sidekick_bin_lib/Drup_lexer/index.html | 2 +- .../Sidekick_bin_lib/Drup_parser/index.html | 2 +- .../Sidekick_bin_lib/Trace_setup/index.html | 2 + dev/sidekick-bin/Sidekick_bin_lib/index.html | 2 +- dev/sidekick-bin/index.html | 2 +- dev/sidekick/Sidekick_abstract_solver/.dummy | 0 .../Asolver/class-type-t/index.html | 12 +- .../Asolver/index.html | 16 +- .../Check_res/index.html | 2 +- .../Unknown/index.html | 2 +- .../class-type-t/index.html | 12 +- .../Sidekick_abstract_solver/index.html | 2 +- dev/sidekick/Sidekick_arith/.dummy | 0 dev/sidekick/Sidekick_arith/index.html | 2 +- .../Sidekick_arith/module-type-INT/index.html | 2 +- .../module-type-INT_FULL/index.html | 2 +- .../Sidekick_arith/module-type-NUM/index.html | 2 +- .../module-type-RATIONAL/index.html | 2 +- dev/sidekick/Sidekick_bencode/.dummy | 0 .../Sidekick_bencode/Decode/index.html | 2 +- .../Sidekick_bencode/Encode/index.html | 2 +- dev/sidekick/Sidekick_bencode/index.html | 2 +- dev/sidekick/Sidekick_cc/.dummy | 0 .../Sidekick_cc/CC/Handler_action/index.html | 2 +- .../CC/Make/argument-1-_/index.html | 2 +- dev/sidekick/Sidekick_cc/CC/Make/index.html | 8 +- .../Sidekick_cc/CC/Result_action/index.html | 2 +- dev/sidekick/Sidekick_cc/CC/index.html | 16 +- .../Sidekick_cc/CC/module-type-ARG/index.html | 2 +- .../CC/module-type-BUILD/index.html | 8 +- .../Sidekick_cc/E_node/Internal_/index.html | 2 +- dev/sidekick/Sidekick_cc/E_node/index.html | 2 +- dev/sidekick/Sidekick_cc/Expl/index.html | 4 +- .../Plugin/Make/argument-1-M/index.html | 4 +- .../Sidekick_cc/Plugin/Make/index.html | 2 +- .../Make/module-type-DYN_PL_FOR_M/index.html | 2 +- dev/sidekick/Sidekick_cc/Plugin/index.html | 2 +- .../M/index.html | 4 +- .../index.html | 2 +- .../module-type-DYN_PL_FOR_M/index.html | 2 +- .../Sidekick_cc/Resolved_expl/index.html | 2 +- dev/sidekick/Sidekick_cc/Signature/index.html | 4 +- dev/sidekick/Sidekick_cc/index.html | 20 +- .../M/index.html | 4 +- .../module-type-DYN_MONOID_PLUGIN/index.html | 2 +- .../module-type-MONOID_PLUGIN_ARG/index.html | 4 +- .../M/index.html | 4 +- .../index.html | 2 +- .../module-type-DYN_PL_FOR_M/index.html | 2 +- dev/sidekick/Sidekick_cc_plugin/.dummy | 0 dev/sidekick/Sidekick_cc_plugin/index.html | 2 +- dev/sidekick/Sidekick_core/.dummy | 0 .../Sidekick_core/Bool_view/index.html | 2 +- dev/sidekick/Sidekick_core/Box/index.html | 4 +- dev/sidekick/Sidekick_core/CC_view/index.html | 16 +- .../Sidekick_core/Default_cc_view/index.html | 4 +- dev/sidekick/Sidekick_core/Gensym/index.html | 2 +- dev/sidekick/Sidekick_core/Lit/index.html | 2 +- .../Sidekick_core/Term/Hooks/index.html | 6 +- .../Sidekick_core/Term/Ref/index.html | 6 +- .../Term/Trace_reader/index.html | 8 +- .../Term/Tracer/class-concrete/index.html | 2 +- .../Term/Tracer/class-dummy/index.html | 2 +- .../Term/Tracer/class-type-t/index.html | 2 +- .../Sidekick_core/Term/Tracer/index.html | 2 +- dev/sidekick/Sidekick_core/Term/index.html | 12 +- dev/sidekick/Sidekick_core/index.html | 4 +- dev/sidekick/Sidekick_core_logic/.dummy | 0 .../Sidekick_core_logic/Bvar/index.html | 2 +- .../Sidekick_core_logic/Const/Ops/index.html | 4 +- .../Sidekick_core_logic/Const/index.html | 6 +- .../Sidekick_core_logic/Str_const/index.html | 6 +- .../Sidekick_core_logic/Subst/index.html | 6 +- .../Sidekick_core_logic/T_builtins/index.html | 2 +- .../Sidekick_core_logic/Term/DB/index.html | 2 +- .../Sidekick_core_logic/Term/Store/index.html | 2 +- .../Sidekick_core_logic/Term/index.html | 8 +- .../Sidekick_core_logic/Var/index.html | 4 +- dev/sidekick/Sidekick_core_logic/index.html | 2 +- dev/sidekick/Sidekick_drup/.dummy | 0 .../Sidekick_drup/Make/Atom/index.html | 2 +- .../Sidekick_drup/Make/Checker/index.html | 2 +- .../Sidekick_drup/Make/Clause/index.html | 2 +- dev/sidekick/Sidekick_drup/Make/index.html | 2 +- dev/sidekick/Sidekick_drup/index.html | 2 +- .../module-type-S/Atom/index.html | 2 +- .../module-type-S/Checker/index.html | 2 +- .../module-type-S/Clause/index.html | 2 +- .../Sidekick_drup/module-type-S/index.html | 2 +- dev/sidekick/Sidekick_memtrace/.dummy | 0 dev/sidekick/Sidekick_memtrace/index.html | 8 +- dev/sidekick/Sidekick_mini_cc/.dummy | 0 dev/sidekick/Sidekick_mini_cc/index.html | 2 +- .../module-type-ARG/index.html | 4 +- dev/sidekick/Sidekick_proof/.dummy | 0 .../Sidekick_proof/Core_rules/index.html | 12 +- dev/sidekick/Sidekick_proof/Pterm/index.html | 14 +- .../Sidekick_proof/Sat_rules/index.html | 2 +- dev/sidekick/Sidekick_proof/Step/index.html | 2 +- .../Sidekick_proof/Step_vec/index.html | 2 +- .../Sidekick_proof/Trace_reader/index.html | 6 +- .../Tracer/class-concrete/index.html | 2 +- .../Tracer/class-dummy/index.html | 2 +- .../Tracer/class-type-t/index.html | 2 +- dev/sidekick/Sidekick_proof/Tracer/index.html | 2 +- dev/sidekick/Sidekick_proof/index.html | 2 +- dev/sidekick/Sidekick_quip/.dummy | 0 .../Sidekick_quip/Proof/Fun/index.html | 2 +- .../Sidekick_quip/Proof/Lit/index.html | 6 +- dev/sidekick/Sidekick_quip/Proof/T/index.html | 2 +- .../Sidekick_quip/Proof/Ty/index.html | 2 +- dev/sidekick/Sidekick_quip/Proof/index.html | 2 +- dev/sidekick/Sidekick_quip/index.html | 2 +- dev/sidekick/Sidekick_sat/.dummy | 0 .../Sidekick_sat/Solver/Clause/index.html | 2 +- dev/sidekick/Sidekick_sat/Solver/index.html | 32 +- .../Tracer/class-dummy/index.html | 4 +- .../Tracer/class-type-t/index.html | 4 +- dev/sidekick/Sidekick_sat/Tracer/index.html | 8 +- dev/sidekick/Sidekick_sat/index.html | 36 +- .../Sidekick_sat/module-type-ACTS/index.html | 6 +- .../module-type-PLUGIN/index.html | 2 +- .../module-type-SAT_STATE/index.html | 2 +- .../module-type-THEORY_CDCL_T/index.html | 2 +- .../module-type-UNSAT_STATE/index.html | 2 +- dev/sidekick/Sidekick_sigs/.dummy | 0 dev/sidekick/Sidekick_sigs/index.html | 2 +- .../module-type-BACKTRACKABLE0/index.html | 2 +- .../module-type-BACKTRACKABLE1/index.html | 2 +- .../module-type-BACKTRACKABLE1_CB/index.html | 2 +- .../module-type-DYN_BACKTRACKABLE/index.html | 2 +- .../Sidekick_sigs/module-type-EQ/index.html | 2 +- .../module-type-EQ_HASH_PRINT/index.html | 2 +- .../module-type-EQ_ORD_HASH/index.html | 2 +- .../module-type-EQ_ORD_HASH_PRINT/index.html | 2 +- .../Sidekick_sigs/module-type-HASH/index.html | 2 +- .../Sidekick_sigs/module-type-ORD/index.html | 2 +- .../module-type-PRINT/index.html | 2 +- .../module-type-WITH_SET_MAP_TBL/index.html | 2 +- .../module-type-WITH_WEAK/index.html | 2 +- dev/sidekick/Sidekick_simplex/.dummy | 0 .../Sidekick_simplex/Binary_op/index.html | 2 +- .../Linear_expr/Make/Comb/Infix/index.html | 2 +- .../Linear_expr/Make/Comb/index.html | 2 +- .../Linear_expr/Make/Constr/index.html | 2 +- .../Linear_expr/Make/Expr/Infix/index.html | 2 +- .../Linear_expr/Make/Expr/index.html | 2 +- .../Linear_expr/Make/argument-1-C/index.html | 2 +- .../Make/argument-2-Var/index.html | 2 +- .../Linear_expr/Make/index.html | 2 +- .../Sidekick_simplex/Linear_expr/index.html | 4 +- .../Linear_expr_intf/index.html | 2 +- .../module-type-COEFF/index.html | 2 +- .../module-type-S/C/index.html | 2 +- .../module-type-S/Comb/Infix/index.html | 2 +- .../module-type-S/Comb/index.html | 2 +- .../module-type-S/Constr/index.html | 2 +- .../module-type-S/Expr/Infix/index.html | 2 +- .../module-type-S/Expr/index.html | 2 +- .../module-type-S/Var/index.html | 2 +- .../Linear_expr_intf/module-type-S/index.html | 2 +- .../module-type-VAR/index.html | 2 +- .../Make/Constraint/index.html | 2 +- .../Sidekick_simplex/Make/Subst/index.html | 2 +- .../Make/Unsat_cert/index.html | 2 +- .../Make/argument-1-Arg/Q/index.html | 2 +- .../Make/argument-1-Arg/Var/index.html | 2 +- .../Make/argument-1-Arg/Z/index.html | 2 +- .../Make/argument-1-Arg/index.html | 2 +- dev/sidekick/Sidekick_simplex/Make/index.html | 14 +- dev/sidekick/Sidekick_simplex/Op/index.html | 2 +- .../Sidekick_simplex/Predicate/index.html | 2 +- dev/sidekick/Sidekick_simplex/index.html | 4 +- .../module-type-ARG/Q/index.html | 2 +- .../module-type-ARG/Var/index.html | 2 +- .../module-type-ARG/Z/index.html | 2 +- .../module-type-ARG/index.html | 2 +- .../module-type-S/Constraint/index.html | 2 +- .../module-type-S/Q/index.html | 2 +- .../module-type-S/Subst/index.html | 2 +- .../module-type-S/Unsat_cert/index.html | 2 +- .../module-type-S/V/index.html | 2 +- .../module-type-S/Z/index.html | 2 +- .../Sidekick_simplex/module-type-S/index.html | 14 +- dev/sidekick/Sidekick_simplify/.dummy | 0 dev/sidekick/Sidekick_simplify/index.html | 4 +- dev/sidekick/Sidekick_smt_solver/.dummy | 0 .../Find_foreign/index.html | 2 +- .../module-type-ACTIONS/index.html | 2 +- .../Sidekick_smt_solver/Model/index.html | 2 +- .../Model_builder/index.html | 12 +- .../Sidekick_smt_solver/Preprocess/index.html | 16 +- .../module-type-PREPROCESS_ACTS/index.html | 2 +- .../Sidekick_smt_solver/Registry/index.html | 2 +- .../Sidekick_smt_solver/Sigs/index.html | 4 +- .../Sigs/module-type-ARG/index.html | 2 +- .../Sidekick_smt_solver/Solver/index.html | 40 +- .../Perform_delayed/argument-1-A/index.html | 6 +- .../Perform_delayed/index.html | 2 +- .../Solver_internal/index.html | 28 +- .../module-type-PERFORM_ACTS/index.html | 6 +- .../Sidekick_smt_solver/Theory/index.html | 12 +- .../Theory/module-type-S/index.html | 2 +- .../Sidekick_smt_solver/Theory_id/index.html | 2 +- .../Trace_reader/index.html | 6 +- .../Tracer/class-concrete/index.html | 2 +- .../Tracer/class-dummy/index.html | 2 +- .../Tracer/class-type-t/index.html | 2 +- .../Sidekick_smt_solver/Tracer/index.html | 8 +- dev/sidekick/Sidekick_smt_solver/index.html | 2 +- dev/sidekick/Sidekick_tef/.dummy | 0 dev/sidekick/Sidekick_tef/index.html | 2 - dev/sidekick/Sidekick_th_bool_dyn/.dummy | 0 .../Sidekick_th_bool_dyn/Intf/index.html | 2 +- .../Intf/module-type-ARG/index.html | 2 +- .../Proof_rules/index.html | 2 +- dev/sidekick/Sidekick_th_bool_dyn/index.html | 2 +- dev/sidekick/Sidekick_th_bool_static/.dummy | 0 .../Sidekick_th_bool_static/Intf/index.html | 2 +- .../Intf/module-type-ARG/index.html | 2 +- .../Proof_rules/index.html | 2 +- .../Sidekick_th_bool_static/index.html | 2 +- dev/sidekick/Sidekick_th_cstor/.dummy | 0 dev/sidekick/Sidekick_th_cstor/index.html | 2 +- .../module-type-ARG/index.html | 4 +- dev/sidekick/Sidekick_th_data/.dummy | 0 dev/sidekick/Sidekick_th_data/index.html | 2 +- .../module-type-ARG/Cstor/index.html | 2 +- .../module-type-ARG/index.html | 4 +- .../module-type-DATA_TY/index.html | 2 +- dev/sidekick/Sidekick_th_lra/.dummy | 0 dev/sidekick/Sidekick_th_lra/Intf/index.html | 2 +- .../Intf/module-type-ARG/Q/index.html | 2 +- .../Intf/module-type-ARG/Z/index.html | 2 +- .../Intf/module-type-ARG/index.html | 4 +- dev/sidekick/Sidekick_th_lra/index.html | 2 +- dev/sidekick/Sidekick_th_ty_unin/.dummy | 0 dev/sidekick/Sidekick_th_ty_unin/index.html | 2 +- .../module-type-ARG/index.html | 2 +- dev/sidekick/Sidekick_trace/.dummy | 0 .../Sidekick_trace/Entry_id/index.html | 2 +- dev/sidekick/Sidekick_trace/Sink/index.html | 2 +- .../Sink/module-type-S/index.html | 2 +- dev/sidekick/Sidekick_trace/Source/index.html | 6 +- .../Source/module-type-S/index.html | 6 +- dev/sidekick/Sidekick_trace/index.html | 2 +- dev/sidekick/Sidekick_util/.dummy | 0 .../Sidekick_util/Backtrack_stack/index.html | 2 +- .../Backtrackable_ref/index.html | 2 +- .../Make/argument-1-A/index.html | 2 +- .../Backtrackable_tbl/Make/index.html | 2 +- .../Backtrackable_tbl/index.html | 2 +- .../module-type-ARG/index.html | 2 +- .../module-type-S/index.html | 2 +- dev/sidekick/Sidekick_util/Bag/index.html | 2 +- dev/sidekick/Sidekick_util/Bitvec/index.html | 2 +- .../Sidekick_util/Chunk_stack/Buf/index.html | 2 +- .../Chunk_stack/Reader/index.html | 2 +- .../Chunk_stack/Writer/index.html | 2 +- .../Sidekick_util/Chunk_stack/index.html | 2 +- dev/sidekick/Sidekick_util/Error/index.html | 2 +- .../Sidekick_util/Event/Emitter/index.html | 2 +- dev/sidekick/Sidekick_util/Event/index.html | 2 +- dev/sidekick/Sidekick_util/Hash/index.html | 2 +- .../Sidekick_util/Int_id/Make/index.html | 2 +- dev/sidekick/Sidekick_util/Int_id/index.html | 2 +- .../Int_id/module-type-S/index.html | 2 +- dev/sidekick/Sidekick_util/Log/index.html | 4 +- .../Sidekick_util/Profile/Control/index.html | 2 - dev/sidekick/Sidekick_util/Profile/index.html | 47 ++- .../Profile/module-type-BACKEND/index.html | 13 - .../Sidekick_util/Ser_decode/Error/index.html | 2 +- .../Sidekick_util/Ser_decode/Infix/index.html | 2 +- .../Sidekick_util/Ser_decode/index.html | 2 +- .../Sidekick_util/Ser_value/index.html | 2 +- dev/sidekick/Sidekick_util/Stat/index.html | 2 +- dev/sidekick/Sidekick_util/Util/index.html | 2 +- dev/sidekick/Sidekick_util/Vec/index.html | 6 +- .../Sidekick_util/Vec_float/index.html | 2 +- .../Make_extensions/argument-1-B/index.html | 2 +- .../Vec_sig/Make_extensions/index.html | 2 +- dev/sidekick/Sidekick_util/Vec_sig/index.html | 4 +- .../Vec_sig/module-type-BASE/index.html | 2 +- .../Vec_sig/module-type-BASE_RO/index.html | 2 +- .../Vec_sig/module-type-EXTENSIONS/index.html | 2 +- .../Vec_sig/module-type-S/index.html | 2 +- dev/sidekick/Sidekick_util/Veci/index.html | 2 +- dev/sidekick/Sidekick_util/index.html | 2 +- dev/sidekick/Sidekick_zarith/.dummy | 0 dev/sidekick/Sidekick_zarith/Int/index.html | 2 +- .../Sidekick_zarith/Rational/index.html | 2 +- dev/sidekick/Sidekick_zarith/index.html | 4 +- dev/sidekick/index.html | 2 +- 339 files changed, 1103 insertions(+), 704 deletions(-) create mode 100644 dev/odoc.support/fonts/fira-mono-v14-latin-500.woff2 create mode 100644 dev/odoc.support/fonts/fira-mono-v14-latin-regular.woff2 create mode 100644 dev/odoc.support/fonts/fira-sans-v17-latin-500.woff2 create mode 100644 dev/odoc.support/fonts/fira-sans-v17-latin-500italic.woff2 create mode 100644 dev/odoc.support/fonts/fira-sans-v17-latin-700.woff2 create mode 100644 dev/odoc.support/fonts/fira-sans-v17-latin-700italic.woff2 create mode 100644 dev/odoc.support/fonts/fira-sans-v17-latin-italic.woff2 create mode 100644 dev/odoc.support/fonts/fira-sans-v17-latin-regular.woff2 create mode 100644 dev/odoc.support/fonts/noticia-text-v15-latin-700.woff2 create mode 100644 dev/odoc.support/fonts/noticia-text-v15-latin-italic.woff2 create mode 100644 dev/odoc.support/fonts/noticia-text-v15-latin-regular.woff2 delete mode 100644 dev/sidekick-base/Sidekick_base/.dummy delete mode 100644 dev/sidekick-base/Sidekick_smtlib/.dummy delete mode 100644 dev/sidekick-bin/Sidekick_bin_lib/.dummy create mode 100644 dev/sidekick-bin/Sidekick_bin_lib/Trace_setup/index.html delete mode 100644 dev/sidekick/Sidekick_abstract_solver/.dummy delete mode 100644 dev/sidekick/Sidekick_arith/.dummy delete mode 100644 dev/sidekick/Sidekick_bencode/.dummy delete mode 100644 dev/sidekick/Sidekick_cc/.dummy delete mode 100644 dev/sidekick/Sidekick_cc_plugin/.dummy delete mode 100644 dev/sidekick/Sidekick_core/.dummy delete mode 100644 dev/sidekick/Sidekick_core_logic/.dummy delete mode 100644 dev/sidekick/Sidekick_drup/.dummy delete mode 100644 dev/sidekick/Sidekick_memtrace/.dummy delete mode 100644 dev/sidekick/Sidekick_mini_cc/.dummy delete mode 100644 dev/sidekick/Sidekick_proof/.dummy delete mode 100644 dev/sidekick/Sidekick_quip/.dummy delete mode 100644 dev/sidekick/Sidekick_sat/.dummy delete mode 100644 dev/sidekick/Sidekick_sigs/.dummy delete mode 100644 dev/sidekick/Sidekick_simplex/.dummy delete mode 100644 dev/sidekick/Sidekick_simplify/.dummy delete mode 100644 dev/sidekick/Sidekick_smt_solver/.dummy delete mode 100644 dev/sidekick/Sidekick_tef/.dummy delete mode 100644 dev/sidekick/Sidekick_tef/index.html delete mode 100644 dev/sidekick/Sidekick_th_bool_dyn/.dummy delete mode 100644 dev/sidekick/Sidekick_th_bool_static/.dummy delete mode 100644 dev/sidekick/Sidekick_th_cstor/.dummy delete mode 100644 dev/sidekick/Sidekick_th_data/.dummy delete mode 100644 dev/sidekick/Sidekick_th_lra/.dummy delete mode 100644 dev/sidekick/Sidekick_th_ty_unin/.dummy delete mode 100644 dev/sidekick/Sidekick_trace/.dummy delete mode 100644 dev/sidekick/Sidekick_util/.dummy delete mode 100644 dev/sidekick/Sidekick_util/Profile/Control/index.html delete mode 100644 dev/sidekick/Sidekick_util/Profile/module-type-BACKEND/index.html delete mode 100644 dev/sidekick/Sidekick_zarith/.dummy diff --git a/dev/odoc.support/fonts/fira-mono-v14-latin-500.woff2 b/dev/odoc.support/fonts/fira-mono-v14-latin-500.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..9d07a635ad643cebf9c65bce8dbdad1b6286bd90 GIT binary patch literal 16148 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 literal 0 HcmV?d00001 diff --git a/dev/odoc.support/fonts/fira-mono-v14-latin-regular.woff2 b/dev/odoc.support/fonts/fira-mono-v14-latin-regular.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..edc71a868ab6867ccab1e3b3b772033909548799 GIT binary patch literal 16284 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%0D3brVzzkM-$VsXg*t!-%f< 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 S=daF)={K-yhxDBb0002=D`A}g literal 0 HcmV?d00001 diff --git a/dev/odoc.support/fonts/fira-sans-v17-latin-500.woff2 b/dev/odoc.support/fonts/fira-sans-v17-latin-500.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..24bb8f45f89f43e11b1e6589de9f6fa9f0175e94 GIT binary patch literal 24020 zcmV(_K-9l?Pew8T0RR910A17o5dZ)H0Pw&709|kZ0RR9100000000000000000000 z0000QbQ^)6P8^a-24Db%EC_-y37QrW2nvDaD1pXz3xx^*0X7081Bws?AO(X^2aZn+ zfmIvY-51c)b|BB)Hel%RmaqM~?5hw)*f#Vv|Yt6K)k#sB%h6%F$TYCV_Aic(uWXJSA|5s@

BF$fM9vsYs(%;pVL{QgttFZl2LrhoVLUHN_ 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 literal 0 HcmV?d00001 diff --git a/dev/odoc.support/fonts/noticia-text-v15-latin-italic.woff2 b/dev/odoc.support/fonts/noticia-text-v15-latin-italic.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..9b83b0712894271751c61c2129c16baa44222e3a GIT binary patch literal 17356 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 P&>NsQ4M7L++xr0k%F9lN literal 0 HcmV?d00001 diff --git a/dev/odoc.support/highlight.pack.js b/dev/odoc.support/highlight.pack.js index a3731597..7d1bcd04 100644 --- a/dev/odoc.support/highlight.pack.js +++ b/dev/odoc.support/highlight.pack.js @@ -302,7 +302,238 @@ e["after:highlightBlock"](Object.assign({block:t.el},t))})})(e),s.push(e)} },t.versionString="11.7.0",t.regex={concat:p,lookahead:d,either:f,optional:h, anyNumberOfTimes:u};for(const t in A)"object"==typeof A[t]&&e.exports(A[t]) ;return Object.assign(t,A),t})({});return te}() -;"object"==typeof exports&&"undefined"!=typeof module&&(module.exports=hljs);/*! `xml` grammar compiled for Highlight.js 11.7.0 */ +;"object"==typeof exports&&"undefined"!=typeof module&&(module.exports=hljs);/*! `reasonml` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict";return e=>{ +const n="~?[a-z$_][0-9a-zA-Z$_]*",a="`?[A-Z$_][0-9a-zA-Z$_]*",s="("+["||","++","**","+.","*","/","*.","/.","..."].map((e=>e.split("").map((e=>"\\"+e)).join(""))).join("|")+"|\\|>|&&|==|===)",i="\\s+"+s+"\\s+",r={ +keyword:"and as asr assert begin class constraint do done downto else end exception external for fun function functor if in include inherit initializer land lazy let lor lsl lsr lxor match method mod module mutable new nonrec object of open or private rec sig struct then to try type val virtual when while with", +built_in:"array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 ref string unit ", +literal:"true false" +},l="\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)",t={ +className:"number",relevance:0,variants:[{begin:l},{begin:"\\(-"+l+"\\)"}]},c={ +className:"operator",relevance:0,begin:s},o=[{className:"identifier", +relevance:0,begin:n},c,t],g=[e.QUOTE_STRING_MODE,c,{className:"module", +begin:"\\b"+a,returnBegin:!0,relevance:0,end:".",contains:[{ +className:"identifier",begin:a,relevance:0}]}],b=[{className:"module", +begin:"\\b"+a,returnBegin:!0,end:".",relevance:0,contains:[{ +className:"identifier",begin:a,relevance:0}]}],m={className:"function", +relevance:0,keywords:r,variants:[{begin:"\\s(\\(\\.?.*?\\)|"+n+")\\s*=>", +end:"\\s*=>",returnBegin:!0,relevance:0,contains:[{className:"params", +variants:[{begin:n},{ +begin:"~?[a-z$_][0-9a-zA-Z$_]*(\\s*:\\s*[a-z$_][0-9a-z$_]*(\\(\\s*('?[a-z$_][0-9a-z$_]*\\s*(,'?[a-z$_][0-9a-z$_]*\\s*)*)?\\))?){0,2}" +},{begin:/\(\s*\)/}]}]},{begin:"\\s\\(\\.?[^;\\|]*\\)\\s*=>",end:"\\s=>", +returnBegin:!0,relevance:0,contains:[{className:"params",relevance:0,variants:[{ +begin:n,end:"(,|\\n|\\))",relevance:0,contains:[c,{className:"typing",begin:":", +end:"(,|\\n)",returnBegin:!0,relevance:0,contains:b}]}]}]},{ +begin:"\\(\\.\\s"+n+"\\)\\s*=>"}]};g.push(m);const d={className:"constructor", +begin:a+"\\(",end:"\\)",illegal:"\\n",keywords:r, +contains:[e.QUOTE_STRING_MODE,c,{className:"params",begin:"\\b"+n}]},u={ +className:"pattern-match",begin:"\\|",returnBegin:!0,keywords:r,end:"=>", +relevance:0,contains:[d,c,{relevance:0,className:"constructor",begin:a}]},v={ +className:"module-access",keywords:r,returnBegin:!0,variants:[{ +begin:"\\b("+a+"\\.)+"+n},{begin:"\\b("+a+"\\.)+\\(",end:"\\)",returnBegin:!0, +contains:[m,{begin:"\\(",end:"\\)",relevance:0,skip:!0}].concat(g)},{ +begin:"\\b("+a+"\\.)+\\{",end:/\}/}],contains:g};return b.push(v),{ +name:"ReasonML",aliases:["re"],keywords:r,illegal:"(:-|:=|\\$\\{|\\+=)", +contains:[e.COMMENT("/\\*","\\*/",{illegal:"^(#,\\/\\/)"}),{ +className:"character",begin:"'(\\\\[^']+|[^'])'",illegal:"\\n",relevance:0 +},e.QUOTE_STRING_MODE,{className:"literal",begin:"\\(\\)",relevance:0},{ +className:"literal",begin:"\\[\\|",end:"\\|\\]",relevance:0,contains:o},{ +className:"literal",begin:"\\[",end:"\\]",relevance:0,contains:o},d,{ +className:"operator",begin:i,illegal:"--\x3e",relevance:0 +},t,e.C_LINE_COMMENT_MODE,u,m,{className:"module-def", +begin:"\\bmodule\\s+"+n+"\\s+"+a+"\\s+=\\s+\\{",end:/\}/,returnBegin:!0, +keywords:r,relevance:0,contains:[{className:"module",relevance:0,begin:a},{ +begin:/\{/,end:/\}/,relevance:0,skip:!0}].concat(g)},v]}}})() +;hljs.registerLanguage("reasonml",e)})();/*! `javascript` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict" +;const e="[A-Za-z$_][0-9A-Za-z$_]*",n=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends"],a=["true","false","null","undefined","NaN","Infinity"],t=["Object","Function","Boolean","Symbol","Math","Date","Number","BigInt","String","RegExp","Array","Float32Array","Float64Array","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Int32Array","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array","Set","Map","WeakSet","WeakMap","ArrayBuffer","SharedArrayBuffer","Atomics","DataView","JSON","Promise","Generator","GeneratorFunction","AsyncFunction","Reflect","Proxy","Intl","WebAssembly"],s=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],r=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],c=["arguments","this","super","console","window","document","localStorage","module","global"],i=[].concat(r,t,s) +;return o=>{const l=o.regex,b=e,d={begin:/<[A-Za-z0-9\\._:-]+/, +end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(e,n)=>{ +const a=e[0].length+e.index,t=e.input[a] +;if("<"===t||","===t)return void n.ignoreMatch();let s +;">"===t&&(((e,{after:n})=>{const a="",M={ +match:[/const|var|let/,/\s+/,b,/\s*/,/=\s*/,/(async\s*)?/,l.lookahead(C)], +keywords:"async",className:{1:"keyword",3:"title.function"},contains:[S]} +;return{name:"Javascript",aliases:["js","jsx","mjs","cjs"],keywords:g,exports:{ +PARAMS_CONTAINS:p,CLASS_REFERENCE:R},illegal:/#(?![$_A-z])/, +contains:[o.SHEBANG({label:"shebang",binary:"node",relevance:5}),{ +label:"use_strict",className:"meta",relevance:10, +begin:/^\s*['"]use (strict|asm)['"]/ +},o.APOS_STRING_MODE,o.QUOTE_STRING_MODE,y,N,_,h,{match:/\$\d+/},E,R,{ +className:"attr",begin:b+l.lookahead(":"),relevance:0},M,{ +begin:"("+o.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*", +keywords:"return throw case",relevance:0,contains:[h,o.REGEXP_MODE,{ +className:"function",begin:C,returnBegin:!0,end:"\\s*=>",contains:[{ +className:"params",variants:[{begin:o.UNDERSCORE_IDENT_RE,relevance:0},{ +className:null,begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0, +excludeEnd:!0,keywords:g,contains:p}]}]},{begin:/,/,relevance:0},{match:/\s+/, +relevance:0},{variants:[{begin:"<>",end:""},{ +match:/<[A-Za-z0-9\\._:-]+\s*\/>/},{begin:d.begin, +"on:begin":d.isTrulyOpeningTag,end:d.end}],subLanguage:"xml",contains:[{ +begin:d.begin,end:d.end,skip:!0,contains:["self"]}]}]},O,{ +beginKeywords:"while if switch catch for"},{ +begin:"\\b(?!function)"+o.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{", +returnBegin:!0,label:"func.def",contains:[S,o.inherit(o.TITLE_MODE,{begin:b, +className:"title.function"})]},{match:/\.\.\./,relevance:0},x,{match:"\\$"+b, +relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"}, +contains:[S]},k,{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/, +className:"variable.constant"},w,T,{match:/\$[(.]/}]}}})() +;hljs.registerLanguage("javascript",e)})();/*! `sql` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict";return e=>{ +const r=e.regex,t=e.COMMENT("--","$"),n=["true","false","unknown"],a=["bigint","binary","blob","boolean","char","character","clob","date","dec","decfloat","decimal","float","int","integer","interval","nchar","nclob","national","numeric","real","row","smallint","time","timestamp","varchar","varying","varbinary"],i=["abs","acos","array_agg","asin","atan","avg","cast","ceil","ceiling","coalesce","corr","cos","cosh","count","covar_pop","covar_samp","cume_dist","dense_rank","deref","element","exp","extract","first_value","floor","json_array","json_arrayagg","json_exists","json_object","json_objectagg","json_query","json_table","json_table_primitive","json_value","lag","last_value","lead","listagg","ln","log","log10","lower","max","min","mod","nth_value","ntile","nullif","percent_rank","percentile_cont","percentile_disc","position","position_regex","power","rank","regr_avgx","regr_avgy","regr_count","regr_intercept","regr_r2","regr_slope","regr_sxx","regr_sxy","regr_syy","row_number","sin","sinh","sqrt","stddev_pop","stddev_samp","substring","substring_regex","sum","tan","tanh","translate","translate_regex","treat","trim","trim_array","unnest","upper","value_of","var_pop","var_samp","width_bucket"],s=["create table","insert into","primary key","foreign key","not null","alter table","add constraint","grouping sets","on overflow","character set","respect nulls","ignore nulls","nulls first","nulls last","depth first","breadth first"],o=i,c=["abs","acos","all","allocate","alter","and","any","are","array","array_agg","array_max_cardinality","as","asensitive","asin","asymmetric","at","atan","atomic","authorization","avg","begin","begin_frame","begin_partition","between","bigint","binary","blob","boolean","both","by","call","called","cardinality","cascaded","case","cast","ceil","ceiling","char","char_length","character","character_length","check","classifier","clob","close","coalesce","collate","collect","column","commit","condition","connect","constraint","contains","convert","copy","corr","corresponding","cos","cosh","count","covar_pop","covar_samp","create","cross","cube","cume_dist","current","current_catalog","current_date","current_default_transform_group","current_path","current_role","current_row","current_schema","current_time","current_timestamp","current_path","current_role","current_transform_group_for_type","current_user","cursor","cycle","date","day","deallocate","dec","decimal","decfloat","declare","default","define","delete","dense_rank","deref","describe","deterministic","disconnect","distinct","double","drop","dynamic","each","element","else","empty","end","end_frame","end_partition","end-exec","equals","escape","every","except","exec","execute","exists","exp","external","extract","false","fetch","filter","first_value","float","floor","for","foreign","frame_row","free","from","full","function","fusion","get","global","grant","group","grouping","groups","having","hold","hour","identity","in","indicator","initial","inner","inout","insensitive","insert","int","integer","intersect","intersection","interval","into","is","join","json_array","json_arrayagg","json_exists","json_object","json_objectagg","json_query","json_table","json_table_primitive","json_value","lag","language","large","last_value","lateral","lead","leading","left","like","like_regex","listagg","ln","local","localtime","localtimestamp","log","log10","lower","match","match_number","match_recognize","matches","max","member","merge","method","min","minute","mod","modifies","module","month","multiset","national","natural","nchar","nclob","new","no","none","normalize","not","nth_value","ntile","null","nullif","numeric","octet_length","occurrences_regex","of","offset","old","omit","on","one","only","open","or","order","out","outer","over","overlaps","overlay","parameter","partition","pattern","per","percent","percent_rank","percentile_cont","percentile_disc","period","portion","position","position_regex","power","precedes","precision","prepare","primary","procedure","ptf","range","rank","reads","real","recursive","ref","references","referencing","regr_avgx","regr_avgy","regr_count","regr_intercept","regr_r2","regr_slope","regr_sxx","regr_sxy","regr_syy","release","result","return","returns","revoke","right","rollback","rollup","row","row_number","rows","running","savepoint","scope","scroll","search","second","seek","select","sensitive","session_user","set","show","similar","sin","sinh","skip","smallint","some","specific","specifictype","sql","sqlexception","sqlstate","sqlwarning","sqrt","start","static","stddev_pop","stddev_samp","submultiset","subset","substring","substring_regex","succeeds","sum","symmetric","system","system_time","system_user","table","tablesample","tan","tanh","then","time","timestamp","timezone_hour","timezone_minute","to","trailing","translate","translate_regex","translation","treat","trigger","trim","trim_array","true","truncate","uescape","union","unique","unknown","unnest","update","upper","user","using","value","values","value_of","var_pop","var_samp","varbinary","varchar","varying","versioning","when","whenever","where","width_bucket","window","with","within","without","year","add","asc","collation","desc","final","first","last","view"].filter((e=>!i.includes(e))),l={ +begin:r.concat(/\b/,r.either(...o),/\s*\(/),relevance:0,keywords:{built_in:o}} +;return{name:"SQL",case_insensitive:!0,illegal:/[{}]|<\//,keywords:{ +$pattern:/\b[\w\.]+/,keyword:((e,{exceptions:r,when:t}={})=>{const n=t +;return r=r||[],e.map((e=>e.match(/\|\d+$/)||r.includes(e)?e:n(e)?e+"|0":e)) +})(c,{when:e=>e.length<3}),literal:n,type:a, +built_in:["current_catalog","current_date","current_default_transform_group","current_path","current_role","current_schema","current_transform_group_for_type","current_user","session_user","system_time","system_user","current_time","localtime","current_timestamp","localtimestamp"] +},contains:[{begin:r.either(...s),relevance:0,keywords:{$pattern:/[\w\.]+/, +keyword:c.concat(s),literal:n,type:a}},{className:"type", +begin:r.either("double precision","large object","with timezone","without timezone") +},l,{className:"variable",begin:/@[a-z0-9]+/},{className:"string",variants:[{ +begin:/'/,end:/'/,contains:[{begin:/''/}]}]},{begin:/"/,end:/"/,contains:[{ +begin:/""/}]},e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,t,{className:"operator", +begin:/[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,relevance:0}]}}})() +;hljs.registerLanguage("sql",e)})();/*! `bash` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict";return e=>{const s=e.regex,t={},n={begin:/\$\{/, +end:/\}/,contains:["self",{begin:/:-/,contains:[t]}]};Object.assign(t,{ +className:"variable",variants:[{ +begin:s.concat(/\$[\w\d#@][\w\d_]*/,"(?![\\w\\d])(?![$])")},n]});const a={ +className:"subst",begin:/\$\(/,end:/\)/,contains:[e.BACKSLASH_ESCAPE]},i={ +begin:/<<-?\s*(?=\w+)/,starts:{contains:[e.END_SAME_AS_BEGIN({begin:/(\w+)/, +end:/(\w+)/,className:"string"})]}},c={className:"string",begin:/"/,end:/"/, +contains:[e.BACKSLASH_ESCAPE,t,a]};a.contains.push(c);const o={begin:/\$?\(\(/, +end:/\)\)/,contains:[{begin:/\d+#[0-9a-f]+/,className:"number"},e.NUMBER_MODE,t] +},r=e.SHEBANG({binary:"(fish|bash|zsh|sh|csh|ksh|tcsh|dash|scsh)",relevance:10 +}),l={className:"function",begin:/\w[\w\d_]*\s*\(\s*\)\s*\{/,returnBegin:!0, +contains:[e.inherit(e.TITLE_MODE,{begin:/\w[\w\d_]*/})],relevance:0};return{ +name:"Bash",aliases:["sh"],keywords:{$pattern:/\b[a-z][a-z0-9._-]+\b/, +keyword:["if","then","else","elif","fi","for","while","in","do","done","case","esac","function"], +literal:["true","false"], +built_in:["break","cd","continue","eval","exec","exit","export","getopts","hash","pwd","readonly","return","shift","test","times","trap","umask","unset","alias","bind","builtin","caller","command","declare","echo","enable","help","let","local","logout","mapfile","printf","read","readarray","source","type","typeset","ulimit","unalias","set","shopt","autoload","bg","bindkey","bye","cap","chdir","clone","comparguments","compcall","compctl","compdescribe","compfiles","compgroups","compquote","comptags","comptry","compvalues","dirs","disable","disown","echotc","echoti","emulate","fc","fg","float","functions","getcap","getln","history","integer","jobs","kill","limit","log","noglob","popd","print","pushd","pushln","rehash","sched","setcap","setopt","stat","suspend","ttyctl","unfunction","unhash","unlimit","unsetopt","vared","wait","whence","where","which","zcompile","zformat","zftp","zle","zmodload","zparseopts","zprof","zpty","zregexparse","zsocket","zstyle","ztcp","chcon","chgrp","chown","chmod","cp","dd","df","dir","dircolors","ln","ls","mkdir","mkfifo","mknod","mktemp","mv","realpath","rm","rmdir","shred","sync","touch","truncate","vdir","b2sum","base32","base64","cat","cksum","comm","csplit","cut","expand","fmt","fold","head","join","md5sum","nl","numfmt","od","paste","ptx","pr","sha1sum","sha224sum","sha256sum","sha384sum","sha512sum","shuf","sort","split","sum","tac","tail","tr","tsort","unexpand","uniq","wc","arch","basename","chroot","date","dirname","du","echo","env","expr","factor","groups","hostid","id","link","logname","nice","nohup","nproc","pathchk","pinky","printenv","printf","pwd","readlink","runcon","seq","sleep","stat","stdbuf","stty","tee","test","timeout","tty","uname","unlink","uptime","users","who","whoami","yes"] +},contains:[r,e.SHEBANG(),l,o,e.HASH_COMMENT_MODE,i,{match:/(\/[a-z._-]+)+/},c,{ +className:"",begin:/\\"/},{className:"string",begin:/'/,end:/'/},t]}}})() +;hljs.registerLanguage("bash",e)})();/*! `shell` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var s=(()=>{"use strict";return s=>({name:"Shell Session", +aliases:["console","shellsession"],contains:[{className:"meta.prompt", +begin:/^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/,starts:{end:/[^\\](?=\s*$)/, +subLanguage:"bash"}}]})})();hljs.registerLanguage("shell",s)})();/*! `plaintext` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var t=(()=>{"use strict";return t=>({name:"Plain text", +aliases:["text","txt"],disableAutodetect:!0})})() +;hljs.registerLanguage("plaintext",t)})();/*! `graphql` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict";return e=>{const a=e.regex;return{name:"GraphQL", +aliases:["gql"],case_insensitive:!0,disableAutodetect:!1,keywords:{ +keyword:["query","mutation","subscription","type","input","schema","directive","interface","union","scalar","fragment","enum","on"], +literal:["true","false","null"]}, +contains:[e.HASH_COMMENT_MODE,e.QUOTE_STRING_MODE,e.NUMBER_MODE,{ +scope:"punctuation",match:/[.]{3}/,relevance:0},{scope:"punctuation", +begin:/[\!\(\)\:\=\[\]\{\|\}]{1}/,relevance:0},{scope:"variable",begin:/\$/, +end:/\W/,excludeEnd:!0,relevance:0},{scope:"meta",match:/@\w+/,excludeEnd:!0},{ +scope:"symbol",begin:a.concat(/[_A-Za-z][_0-9A-Za-z]*/,a.lookahead(/\s*:/)), +relevance:0}],illegal:[/[;<']/,/BEGIN/]}}})();hljs.registerLanguage("graphql",e) +})();/*! `ocaml` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict";return e=>({name:"OCaml",aliases:["ml"], +keywords:{$pattern:"[a-z_]\\w*!?", +keyword:"and as assert asr begin class constraint do done downto else end exception external for fun function functor if in include inherit! inherit initializer land lazy let lor lsl lsr lxor match method!|10 method mod module mutable new object of open! open or private rec sig struct then to try type val! val virtual when while with parser value", +built_in:"array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 string unit in_channel out_channel ref", +literal:"true false"},illegal:/\/\/|>>/,contains:[{className:"literal", +begin:"\\[(\\|\\|)?\\]|\\(\\)",relevance:0},e.COMMENT("\\(\\*","\\*\\)",{ +contains:["self"]}),{className:"symbol",begin:"'[A-Za-z_](?!')[\\w']*"},{ +className:"type",begin:"`[A-Z][\\w']*"},{className:"type", +begin:"\\b[A-Z][\\w']*",relevance:0},{begin:"[a-z_]\\w*'[\\w']*",relevance:0 +},e.inherit(e.APOS_STRING_MODE,{className:"string",relevance:0 +}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),{className:"number", +begin:"\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)", +relevance:0},{begin:/->/}]})})();hljs.registerLanguage("ocaml",e)})();/*! `json` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict";return e=>{const a=["true","false","null"],n={ +scope:"literal",beginKeywords:a.join(" ")};return{name:"JSON",keywords:{ +literal:a},contains:[{className:"attr",begin:/"(\\.|[^\\"\r\n])*"(?=\s*:)/, +relevance:1.01},{match:/[{}[\],:]/,className:"punctuation",relevance:0 +},e.QUOTE_STRING_MODE,n,e.C_NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE], +illegal:"\\S"}}})();hljs.registerLanguage("json",e)})();/*! `python` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict";return e=>{ +const n=e.regex,a=/[\p{XID_Start}_]\p{XID_Continue}*/u,i=["and","as","assert","async","await","break","case","class","continue","def","del","elif","else","except","finally","for","from","global","if","import","in","is","lambda","match","nonlocal|10","not","or","pass","raise","return","try","while","with","yield"],s={ +$pattern:/[A-Za-z]\w+|__\w+__/,keyword:i, +built_in:["__import__","abs","all","any","ascii","bin","bool","breakpoint","bytearray","bytes","callable","chr","classmethod","compile","complex","delattr","dict","dir","divmod","enumerate","eval","exec","filter","float","format","frozenset","getattr","globals","hasattr","hash","help","hex","id","input","int","isinstance","issubclass","iter","len","list","locals","map","max","memoryview","min","next","object","oct","open","ord","pow","print","property","range","repr","reversed","round","set","setattr","slice","sorted","staticmethod","str","sum","super","tuple","type","vars","zip"], +literal:["__debug__","Ellipsis","False","None","NotImplemented","True"], +type:["Any","Callable","Coroutine","Dict","List","Literal","Generic","Optional","Sequence","Set","Tuple","Type","Union"] +},t={className:"meta",begin:/^(>>>|\.\.\.) /},r={className:"subst",begin:/\{/, +end:/\}/,keywords:s,illegal:/#/},l={begin:/\{\{/,relevance:0},b={ +className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{ +begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,end:/'''/, +contains:[e.BACKSLASH_ESCAPE,t],relevance:10},{ +begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,end:/"""/, +contains:[e.BACKSLASH_ESCAPE,t],relevance:10},{ +begin:/([fF][rR]|[rR][fF]|[fF])'''/,end:/'''/, +contains:[e.BACKSLASH_ESCAPE,t,l,r]},{begin:/([fF][rR]|[rR][fF]|[fF])"""/, +end:/"""/,contains:[e.BACKSLASH_ESCAPE,t,l,r]},{begin:/([uU]|[rR])'/,end:/'/, +relevance:10},{begin:/([uU]|[rR])"/,end:/"/,relevance:10},{ +begin:/([bB]|[bB][rR]|[rR][bB])'/,end:/'/},{begin:/([bB]|[bB][rR]|[rR][bB])"/, +end:/"/},{begin:/([fF][rR]|[rR][fF]|[fF])'/,end:/'/, +contains:[e.BACKSLASH_ESCAPE,l,r]},{begin:/([fF][rR]|[rR][fF]|[fF])"/,end:/"/, +contains:[e.BACKSLASH_ESCAPE,l,r]},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE] +},o="[0-9](_?[0-9])*",c=`(\\b(${o}))?\\.(${o})|\\b(${o})\\.`,d="\\b|"+i.join("|"),g={ +className:"number",relevance:0,variants:[{ +begin:`(\\b(${o})|(${c}))[eE][+-]?(${o})[jJ]?(?=${d})`},{begin:`(${c})[jJ]?`},{ +begin:`\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${d})`},{ +begin:`\\b0[bB](_?[01])+[lL]?(?=${d})`},{begin:`\\b0[oO](_?[0-7])+[lL]?(?=${d})` +},{begin:`\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${d})`},{begin:`\\b(${o})[jJ](?=${d})` +}]},p={className:"comment",begin:n.lookahead(/# type:/),end:/$/,keywords:s, +contains:[{begin:/# type:/},{begin:/#/,end:/\b\B/,endsWithParent:!0}]},m={ +className:"params",variants:[{className:"",begin:/\(\s*\)/,skip:!0},{begin:/\(/, +end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:s, +contains:["self",t,g,b,e.HASH_COMMENT_MODE]}]};return r.contains=[b,g,t],{ +name:"Python",aliases:["py","gyp","ipython"],unicodeRegex:!0,keywords:s, +illegal:/(<\/|->|\?)|=>/,contains:[t,g,{begin:/\bself\b/},{beginKeywords:"if", +relevance:0},b,p,e.HASH_COMMENT_MODE,{match:[/\bdef/,/\s+/,a],scope:{ +1:"keyword",3:"title.function"},contains:[m]},{variants:[{ +match:[/\bclass/,/\s+/,a,/\s*/,/\(\s*/,a,/\s*\)/]},{match:[/\bclass/,/\s+/,a]}], +scope:{1:"keyword",3:"title.class",6:"title.class.inherited"}},{ +className:"meta",begin:/^[\t ]*@/,end:/(?=#)|$/,contains:[g,m,b]}]}}})() +;hljs.registerLanguage("python",e)})();/*! `xml` grammar compiled for Highlight.js 11.7.0 */ (()=>{var e=(()=>{"use strict";return e=>{ const a=e.regex,n=a.concat(/[\p{L}_]/u,a.optional(/[\p{L}0-9_.-]*:/u),/[\p{L}0-9_.-]*/u),s={ className:"symbol",begin:/&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/},t={begin:/\s/, @@ -360,102 +591,44 @@ contains:[{begin:"^( {4}|\\t)",end:"(\\n)$"}],relevance:0}]},{ begin:"^[-\\*]{3,}",end:"$"},a,{begin:/^\[[^\n]+\]:/,returnBegin:!0,contains:[{ className:"symbol",begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0},{ className:"link",begin:/:\s*/,end:/$/,excludeBegin:!0}]}]}}})() -;hljs.registerLanguage("markdown",e)})();/*! `plaintext` grammar compiled for Highlight.js 11.7.0 */ -(()=>{var t=(()=>{"use strict";return t=>({name:"Plain text", -aliases:["text","txt"],disableAutodetect:!0})})() -;hljs.registerLanguage("plaintext",t)})();/*! `ocaml` grammar compiled for Highlight.js 11.7.0 */ -(()=>{var e=(()=>{"use strict";return e=>({name:"OCaml",aliases:["ml"], -keywords:{$pattern:"[a-z_]\\w*!?", -keyword:"and as assert asr begin class constraint do done downto else end exception external for fun function functor if in include inherit! inherit initializer land lazy let lor lsl lsr lxor match method!|10 method mod module mutable new object of open! open or private rec sig struct then to try type val! val virtual when while with parser value", -built_in:"array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 string unit in_channel out_channel ref", -literal:"true false"},illegal:/\/\/|>>/,contains:[{className:"literal", -begin:"\\[(\\|\\|)?\\]|\\(\\)",relevance:0},e.COMMENT("\\(\\*","\\*\\)",{ -contains:["self"]}),{className:"symbol",begin:"'[A-Za-z_](?!')[\\w']*"},{ -className:"type",begin:"`[A-Z][\\w']*"},{className:"type", -begin:"\\b[A-Z][\\w']*",relevance:0},{begin:"[a-z_]\\w*'[\\w']*",relevance:0 -},e.inherit(e.APOS_STRING_MODE,{className:"string",relevance:0 -}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),{className:"number", -begin:"\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)", -relevance:0},{begin:/->/}]})})();hljs.registerLanguage("ocaml",e)})();/*! `python` grammar compiled for Highlight.js 11.7.0 */ -(()=>{var e=(()=>{"use strict";return e=>{ -const n=e.regex,a=/[\p{XID_Start}_]\p{XID_Continue}*/u,i=["and","as","assert","async","await","break","case","class","continue","def","del","elif","else","except","finally","for","from","global","if","import","in","is","lambda","match","nonlocal|10","not","or","pass","raise","return","try","while","with","yield"],s={ -$pattern:/[A-Za-z]\w+|__\w+__/,keyword:i, -built_in:["__import__","abs","all","any","ascii","bin","bool","breakpoint","bytearray","bytes","callable","chr","classmethod","compile","complex","delattr","dict","dir","divmod","enumerate","eval","exec","filter","float","format","frozenset","getattr","globals","hasattr","hash","help","hex","id","input","int","isinstance","issubclass","iter","len","list","locals","map","max","memoryview","min","next","object","oct","open","ord","pow","print","property","range","repr","reversed","round","set","setattr","slice","sorted","staticmethod","str","sum","super","tuple","type","vars","zip"], -literal:["__debug__","Ellipsis","False","None","NotImplemented","True"], -type:["Any","Callable","Coroutine","Dict","List","Literal","Generic","Optional","Sequence","Set","Tuple","Type","Union"] -},t={className:"meta",begin:/^(>>>|\.\.\.) /},r={className:"subst",begin:/\{/, -end:/\}/,keywords:s,illegal:/#/},l={begin:/\{\{/,relevance:0},b={ -className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{ -begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,end:/'''/, -contains:[e.BACKSLASH_ESCAPE,t],relevance:10},{ -begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,end:/"""/, -contains:[e.BACKSLASH_ESCAPE,t],relevance:10},{ -begin:/([fF][rR]|[rR][fF]|[fF])'''/,end:/'''/, -contains:[e.BACKSLASH_ESCAPE,t,l,r]},{begin:/([fF][rR]|[rR][fF]|[fF])"""/, -end:/"""/,contains:[e.BACKSLASH_ESCAPE,t,l,r]},{begin:/([uU]|[rR])'/,end:/'/, -relevance:10},{begin:/([uU]|[rR])"/,end:/"/,relevance:10},{ -begin:/([bB]|[bB][rR]|[rR][bB])'/,end:/'/},{begin:/([bB]|[bB][rR]|[rR][bB])"/, -end:/"/},{begin:/([fF][rR]|[rR][fF]|[fF])'/,end:/'/, -contains:[e.BACKSLASH_ESCAPE,l,r]},{begin:/([fF][rR]|[rR][fF]|[fF])"/,end:/"/, -contains:[e.BACKSLASH_ESCAPE,l,r]},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE] -},o="[0-9](_?[0-9])*",c=`(\\b(${o}))?\\.(${o})|\\b(${o})\\.`,d="\\b|"+i.join("|"),g={ -className:"number",relevance:0,variants:[{ -begin:`(\\b(${o})|(${c}))[eE][+-]?(${o})[jJ]?(?=${d})`},{begin:`(${c})[jJ]?`},{ -begin:`\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${d})`},{ -begin:`\\b0[bB](_?[01])+[lL]?(?=${d})`},{begin:`\\b0[oO](_?[0-7])+[lL]?(?=${d})` -},{begin:`\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${d})`},{begin:`\\b(${o})[jJ](?=${d})` -}]},p={className:"comment",begin:n.lookahead(/# type:/),end:/$/,keywords:s, -contains:[{begin:/# type:/},{begin:/#/,end:/\b\B/,endsWithParent:!0}]},m={ -className:"params",variants:[{className:"",begin:/\(\s*\)/,skip:!0},{begin:/\(/, -end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:s, -contains:["self",t,g,b,e.HASH_COMMENT_MODE]}]};return r.contains=[b,g,t],{ -name:"Python",aliases:["py","gyp","ipython"],unicodeRegex:!0,keywords:s, -illegal:/(<\/|->|\?)|=>/,contains:[t,g,{begin:/\bself\b/},{beginKeywords:"if", -relevance:0},b,p,e.HASH_COMMENT_MODE,{match:[/\bdef/,/\s+/,a],scope:{ -1:"keyword",3:"title.function"},contains:[m]},{variants:[{ -match:[/\bclass/,/\s+/,a,/\s*/,/\(\s*/,a,/\s*\)/]},{match:[/\bclass/,/\s+/,a]}], -scope:{1:"keyword",3:"title.class",6:"title.class.inherited"}},{ -className:"meta",begin:/^[\t ]*@/,end:/(?=#)|$/,contains:[g,m,b]}]}}})() -;hljs.registerLanguage("python",e)})();/*! `reasonml` grammar compiled for Highlight.js 11.7.0 */ -(()=>{var e=(()=>{"use strict";return e=>{ -const n="~?[a-z$_][0-9a-zA-Z$_]*",a="`?[A-Z$_][0-9a-zA-Z$_]*",s="("+["||","++","**","+.","*","/","*.","/.","..."].map((e=>e.split("").map((e=>"\\"+e)).join(""))).join("|")+"|\\|>|&&|==|===)",i="\\s+"+s+"\\s+",r={ -keyword:"and as asr assert begin class constraint do done downto else end exception external for fun function functor if in include inherit initializer land lazy let lor lsl lsr lxor match method mod module mutable new nonrec object of open or private rec sig struct then to try type val virtual when while with", -built_in:"array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 ref string unit ", -literal:"true false" -},l="\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)",t={ -className:"number",relevance:0,variants:[{begin:l},{begin:"\\(-"+l+"\\)"}]},c={ -className:"operator",relevance:0,begin:s},o=[{className:"identifier", -relevance:0,begin:n},c,t],g=[e.QUOTE_STRING_MODE,c,{className:"module", -begin:"\\b"+a,returnBegin:!0,relevance:0,end:".",contains:[{ -className:"identifier",begin:a,relevance:0}]}],b=[{className:"module", -begin:"\\b"+a,returnBegin:!0,end:".",relevance:0,contains:[{ -className:"identifier",begin:a,relevance:0}]}],m={className:"function", -relevance:0,keywords:r,variants:[{begin:"\\s(\\(\\.?.*?\\)|"+n+")\\s*=>", -end:"\\s*=>",returnBegin:!0,relevance:0,contains:[{className:"params", -variants:[{begin:n},{ -begin:"~?[a-z$_][0-9a-zA-Z$_]*(\\s*:\\s*[a-z$_][0-9a-z$_]*(\\(\\s*('?[a-z$_][0-9a-z$_]*\\s*(,'?[a-z$_][0-9a-z$_]*\\s*)*)?\\))?){0,2}" -},{begin:/\(\s*\)/}]}]},{begin:"\\s\\(\\.?[^;\\|]*\\)\\s*=>",end:"\\s=>", -returnBegin:!0,relevance:0,contains:[{className:"params",relevance:0,variants:[{ -begin:n,end:"(,|\\n|\\))",relevance:0,contains:[c,{className:"typing",begin:":", -end:"(,|\\n)",returnBegin:!0,relevance:0,contains:b}]}]}]},{ -begin:"\\(\\.\\s"+n+"\\)\\s*=>"}]};g.push(m);const d={className:"constructor", -begin:a+"\\(",end:"\\)",illegal:"\\n",keywords:r, -contains:[e.QUOTE_STRING_MODE,c,{className:"params",begin:"\\b"+n}]},u={ -className:"pattern-match",begin:"\\|",returnBegin:!0,keywords:r,end:"=>", -relevance:0,contains:[d,c,{relevance:0,className:"constructor",begin:a}]},v={ -className:"module-access",keywords:r,returnBegin:!0,variants:[{ -begin:"\\b("+a+"\\.)+"+n},{begin:"\\b("+a+"\\.)+\\(",end:"\\)",returnBegin:!0, -contains:[m,{begin:"\\(",end:"\\)",relevance:0,skip:!0}].concat(g)},{ -begin:"\\b("+a+"\\.)+\\{",end:/\}/}],contains:g};return b.push(v),{ -name:"ReasonML",aliases:["re"],keywords:r,illegal:"(:-|:=|\\$\\{|\\+=)", -contains:[e.COMMENT("/\\*","\\*/",{illegal:"^(#,\\/\\/)"}),{ -className:"character",begin:"'(\\\\[^']+|[^'])'",illegal:"\\n",relevance:0 -},e.QUOTE_STRING_MODE,{className:"literal",begin:"\\(\\)",relevance:0},{ -className:"literal",begin:"\\[\\|",end:"\\|\\]",relevance:0,contains:o},{ -className:"literal",begin:"\\[",end:"\\]",relevance:0,contains:o},d,{ -className:"operator",begin:i,illegal:"--\x3e",relevance:0 -},t,e.C_LINE_COMMENT_MODE,u,m,{className:"module-def", -begin:"\\bmodule\\s+"+n+"\\s+"+a+"\\s+=\\s+\\{",end:/\}/,returnBegin:!0, -keywords:r,relevance:0,contains:[{className:"module",relevance:0,begin:a},{ -begin:/\{/,end:/\}/,relevance:0,skip:!0}].concat(g)},v]}}})() -;hljs.registerLanguage("reasonml",e)})(); \ No newline at end of file +;hljs.registerLanguage("markdown",e)})();/*! `c` grammar compiled for Highlight.js 11.7.0 */ +(()=>{var e=(()=>{"use strict";return e=>{const n=e.regex,t=e.COMMENT("//","$",{ +contains:[{begin:/\\\n/}] +}),s="[a-zA-Z_]\\w*::",a="(decltype\\(auto\\)|"+n.optional(s)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",r={ +className:"type",variants:[{begin:"\\b[a-z\\d_]*_t\\b"},{ +match:/\batomic_[a-z]{3,6}\b/}]},i={className:"string",variants:[{ +begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{ +begin:"(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)", +end:"'",illegal:"."},e.END_SAME_AS_BEGIN({ +begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},l={ +className:"number",variants:[{begin:"\\b(0b[01']+)"},{ +begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)" +},{ +begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)" +}],relevance:0},o={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{ +keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include" +},contains:[{begin:/\\\n/,relevance:0},e.inherit(i,{className:"string"}),{ +className:"string",begin:/<.*?>/},t,e.C_BLOCK_COMMENT_MODE]},c={ +className:"title",begin:n.optional(s)+e.IDENT_RE,relevance:0 +},d=n.optional(s)+e.IDENT_RE+"\\s*\\(",u={ +keyword:["asm","auto","break","case","continue","default","do","else","enum","extern","for","fortran","goto","if","inline","register","restrict","return","sizeof","struct","switch","typedef","union","volatile","while","_Alignas","_Alignof","_Atomic","_Generic","_Noreturn","_Static_assert","_Thread_local","alignas","alignof","noreturn","static_assert","thread_local","_Pragma"], +type:["float","double","signed","unsigned","int","short","long","char","void","_Bool","_Complex","_Imaginary","_Decimal32","_Decimal64","_Decimal128","const","static","complex","bool","imaginary"], +literal:"true false NULL", +built_in:"std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr" +},g=[o,r,t,e.C_BLOCK_COMMENT_MODE,l,i],m={variants:[{begin:/=/,end:/;/},{ +begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}], +keywords:u,contains:g.concat([{begin:/\(/,end:/\)/,keywords:u, +contains:g.concat(["self"]),relevance:0}]),relevance:0},p={ +begin:"("+a+"[\\*&\\s]+)+"+d,returnBegin:!0,end:/[{;=]/,excludeEnd:!0, +keywords:u,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:"decltype\\(auto\\)", +keywords:u,relevance:0},{begin:d,returnBegin:!0,contains:[e.inherit(c,{ +className:"title.function"})],relevance:0},{relevance:0,match:/,/},{ +className:"params",begin:/\(/,end:/\)/,keywords:u,relevance:0, +contains:[t,e.C_BLOCK_COMMENT_MODE,i,l,r,{begin:/\(/,end:/\)/,keywords:u, +relevance:0,contains:["self",t,e.C_BLOCK_COMMENT_MODE,i,l,r]}] +},r,t,e.C_BLOCK_COMMENT_MODE,o]};return{name:"C",aliases:["h"],keywords:u, +disableAutodetect:!0,illegal:"=]/,contains:[{ +beginKeywords:"final class struct"},e.TITLE_MODE]}]),exports:{preprocessor:o, +strings:i,keywords:u}}}})();hljs.registerLanguage("c",e)})(); diff --git a/dev/odoc.support/odoc.css b/dev/odoc.support/odoc.css index 8b0ed5a8..7230f826 100644 --- a/dev/odoc.support/odoc.css +++ b/dev/odoc.support/odoc.css @@ -1,12 +1,97 @@ @charset "UTF-8"; /* Copyright (c) 2016 The odoc contributors. All rights reserved. Distributed under the ISC license, see terms at the end of the file. - odoc 2.2.0 */ + odoc 2.3.0 */ /* Fonts */ -@import url('https://fonts.googleapis.com/css?family=Fira+Mono:400,500'); -@import url('https://fonts.googleapis.com/css?family=Noticia+Text:400,400i,700'); -@import url('https://fonts.googleapis.com/css?family=Fira+Sans:400,400i,500,500i,600,600i,700,700i'); +/* noticia-text-regular - latin */ +@font-face { + font-family: 'Noticia Text'; + font-style: normal; + font-weight: 400; + src: url('fonts/noticia-text-v15-latin-regular.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* noticia-text-italic - latin */ +@font-face { + font-family: 'Noticia Text'; + font-style: italic; + font-weight: 400; + src: url('fonts/noticia-text-v15-latin-italic.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* noticia-text-700 - latin */ +@font-face { + font-family: 'Noticia Text'; + font-style: normal; + font-weight: 700; + src: url('fonts/noticia-text-v15-latin-700.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* fira-mono-regular - latin */ +@font-face { + font-family: 'Fira Mono'; + font-style: normal; + font-weight: 400; + src: url('fonts/fira-mono-v14-latin-regular.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* fira-mono-500 - latin */ +@font-face { + font-family: 'Fira Mono'; + font-style: normal; + font-weight: 500; + src: url('fonts/fira-mono-v14-latin-500.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* fira-sans-regular - latin */ +@font-face { + font-family: 'Fira Sans'; + font-style: normal; + font-weight: 400; + src: url('fonts/fira-sans-v17-latin-regular.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* fira-sans-italic - latin */ +@font-face { + font-family: 'Fira Sans'; + font-style: italic; + font-weight: 400; + src: url('fonts/fira-sans-v17-latin-italic.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* fira-sans-500 - latin */ +@font-face { + font-family: 'Fira Sans'; + font-style: normal; + font-weight: 500; + src: url('fonts/fira-sans-v17-latin-500.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* fira-sans-500italic - latin */ +@font-face { + font-family: 'Fira Sans'; + font-style: italic; + font-weight: 500; + src: url('fonts/fira-sans-v17-latin-500italic.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* fira-sans-700 - latin */ +@font-face { + font-family: 'Fira Sans'; + font-style: normal; + font-weight: 700; + src: url('fonts/fira-sans-v17-latin-700.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + +/* fira-sans-700italic - latin */ +@font-face { + font-family: 'Fira Sans'; + font-style: italic; + font-weight: 700; + src: url('fonts/fira-sans-v17-latin-700italic.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */ +} + :root, .light:root { @@ -14,6 +99,7 @@ --color: #333333; --link-color: #2C94BD; + --source-color: grey; --anchor-hover: #555; --anchor-color: #d5d5d5; --xref-shadow: #cc6666; @@ -33,6 +119,7 @@ --toc-list-border: #ccc; --spec-summary-border-color: #5c9cf5; + --spec-label-color: green; --spec-summary-background: var(--code-background); --spec-summary-hover-background: #ebeff2; --spec-details-after-background: rgba(0, 4, 15, 0.05); @@ -72,6 +159,8 @@ --hljs-type: #ac885b; --hljs-meta: #82aaff; --hljs-variable: #cf6a4c; + + --spec-label-color: lightgreen; } @media (prefers-color-scheme: dark) { @@ -118,6 +207,8 @@ --hljs-type: #ac885b; --hljs-meta: #82aaff; --hljs-variable: #cf6a4c; + + --spec-label-color: lightgreen; } } @@ -142,6 +233,7 @@ table { html { font-size: 15px; + scroll-behavior: smooth; } body { @@ -149,16 +241,23 @@ body { background: #FFFFFF; color: var(--color); background-color: var(--main-background); + font-family: "Noticia Text", Georgia, serif; + line-height: 1.5; } body { - max-width: 100ex; margin-left: calc(10vw + 20ex); margin-right: 4ex; margin-top: 20px; margin-bottom: 50px; - font-family: "Noticia Text", Georgia, serif; - line-height: 1.5; +} + +body.odoc { + max-width: 100ex; +} + +body.odoc-src { + margin-right: calc(10vw + 20ex); } header { @@ -238,6 +337,10 @@ a { color: var(--link-color); } +.odoc-src pre a { + color: inherit; +} + a:hover { box-shadow: 0 1px 0 0 var(--link-color); } @@ -289,6 +392,14 @@ a.anchor { box-shadow: 0 1px 0 0 var(--xref-shadow); } +/* Source links float inside preformated text or headings. */ +a.source_link { + float: right; + color: var(--source-color); + font-family: "Fira Sans", Helvetica, Arial, sans-serif; + font-size: initial; +} + /* Section and document divisions. Until at least 4.03 many of the modules of the stdlib start at .h7, we restart the sequence there like h2 */ @@ -372,32 +483,32 @@ tt, code, pre { font-weight: 400; } -pre { +.odoc pre { padding: 0.1em; border: 1px solid var(--pre-border-color); border-radius: 5px; overflow-x: auto; } -p code, -li code { +.odoc p code, +.odoc li code { background-color: var(--li-code-background); color: var(--li-code-color); border-radius: 3px; padding: 0 0.3ex; } -p a > code { +p a > code, li a > code { color: var(--link-color); } -code { +.odoc code { white-space: pre-wrap; } /* Code blocks (e.g. Examples) */ -pre code { +.odoc pre code { font-size: 0.893rem; } @@ -419,6 +530,10 @@ pre code { padding: 0.35em 0.5em; } +.spec .label, .spec .optlabel { + color: var(--spec-label-color); +} + li:not(:last-child) > .def-doc { margin-bottom: 15px; } @@ -536,6 +651,12 @@ td.def-doc *:first-child { .at-tags li { padding-left: 3ex; text-indent: -3ex; } .at-tags .at-tag { text-transform: capitalize } +/* Alert emoji */ + +.alert::before, .deprecated::before { + content: '⚠️ '; +} + /* Lists of modules */ .modules { list-style-type: none; margin-left: -3ex; } @@ -674,10 +795,26 @@ td.def-doc *:first-child { padding-left: 12px; } +/* Tables */ + +.odoc-table { + margin: 1em; +} + +.odoc-table td, .odoc-table th { + padding-left: 0.5em; + padding-right: 0.5em; + border: 1px solid black; +} + +.odoc-table th { + font-weight: bold; +} + /* Mobile adjustements. */ -@media only screen and (max-width: 95ex) { - body.odoc { +@media only screen and (max-width: 110ex) { + body { margin: 2em; } .odoc-toc { @@ -704,6 +841,47 @@ td.def-doc *:first-child { } } +/* Source code. */ + +.source_container { + display: flex; +} + +.source_line_column { + padding-right: 0.5em; + text-align: right; + background: #eee8d5; +} + +.source_line { + padding: 0 1em; +} + +.source_code { + flex-grow: 1; + background: #fdf6e3; + padding: 0 0.3em; + color: #657b83; +} + +/* Source directories */ + +.odoc-directory::before { + content: "📁"; + margin: 0.3em; + font-size: 1.3em; +} + +.odoc-file::before { + content: "📄"; + margin: 0.3em; + font-size: 1.3em; +} + +.odoc-folder-list { + list-style: none; +} + /* Syntax highlighting (based on github-gist) */ .hljs { @@ -777,6 +955,34 @@ td.def-doc *:first-child { text-decoration: underline; } +.VAL, .TYPE, .LET, .REC, .IN, .OPEN, .NONREC, .MODULE, .METHOD, .LETOP, .INHERIT, .INCLUDE, .FUNCTOR, .EXTERNAL, .CONSTRAINT, .ASSERT, .AND, .END, .CLASS, .STRUCT, .SIG { + color: #859900;; +} + +.WITH, .WHILE, .WHEN, .VIRTUAL, .TRY, .TO, .THEN, .PRIVATE, .OF, .NEW, .MUTABLE, .MATCH, .LAZY, .IF, .FUNCTION, .FUN, .FOR, .EXCEPTION, .ELSE, .TO, .DOWNTO, .DO, .DONE, .BEGIN, .AS { + color: #cb4b16; +} + +.TRUE, .FALSE { + color: #b58900; +} + +.failwith, .INT, .SEMISEMI, .LIDENT { + color: #2aa198; +} + +.STRING, .CHAR, .UIDENT { + color: #b58900; +} + +.DOCSTRING { + color: #268bd2; +} + +.COMMENT { + color: #93a1a1; +} + /*--------------------------------------------------------------------------- Copyright (c) 2016 The odoc contributors diff --git a/dev/sidekick-base/Sidekick_base/.dummy b/dev/sidekick-base/Sidekick_base/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick-base/Sidekick_base/Config/Key/index.html b/dev/sidekick-base/Sidekick_base/Config/Key/index.html index 0172705f..7f99c503 100644 --- a/dev/sidekick-base/Sidekick_base/Config/Key/index.html +++ b/dev/sidekick-base/Sidekick_base/Config/Key/index.html @@ -1,2 +1,2 @@ -Key (sidekick-base.Sidekick_base.Config.Key)

Module Config.Key

type 'a t
val create : unit -> 'a t
val equal : 'a t -> 'a t -> bool

Compare two keys that have compatible types

\ No newline at end of file +Key (sidekick-base.Sidekick_base.Config.Key)

Module Config.Key

type 'a t
val create : unit -> 'a t
val equal : 'a t -> 'a t -> bool

Compare two keys that have compatible types

diff --git a/dev/sidekick-base/Sidekick_base/Config/index.html b/dev/sidekick-base/Sidekick_base/Config/index.html index 6f6eeb69..61cca778 100644 --- a/dev/sidekick-base/Sidekick_base/Config/index.html +++ b/dev/sidekick-base/Sidekick_base/Config/index.html @@ -1,2 +1,2 @@ -Config (sidekick-base.Sidekick_base.Config)

Module Sidekick_base.Config

Configuration

module Key : sig ... end
type t
val empty : t
val mem : _ Key.t -> t -> bool
val add : 'a Key.t -> 'a -> t -> t
val length : t -> int
val cardinal : t -> int
val find : 'a Key.t -> t -> 'a option
val find_exn : 'a Key.t -> t -> 'a
  • raises Not_found

    if the key is not in the table

type pair =
  1. | Pair : 'a Key.t * 'a -> pair
val iter : (pair -> unit) -> t -> unit
val to_iter : t -> pair Iter.t
val of_iter : pair Iter.t -> t
val add_iter : t -> pair Iter.t -> t
val add_list : t -> pair list -> t
val of_list : pair list -> t
val to_list : t -> pair list
\ No newline at end of file +Config (sidekick-base.Sidekick_base.Config)

Module Sidekick_base.Config

Configuration

module Key : sig ... end
type t
val empty : t
val mem : _ Key.t -> t -> bool
val add : 'a Key.t -> 'a -> t -> t
val length : t -> int
val cardinal : t -> int
val find : 'a Key.t -> t -> 'a option
val find_exn : 'a Key.t -> t -> 'a
  • raises Not_found

    if the key is not in the table

type pair =
  1. | Pair : 'a Key.t * 'a -> pair
val iter : (pair -> unit) -> t -> unit
val to_iter : t -> pair Iter.t
val of_iter : pair Iter.t -> t
val add_iter : t -> pair Iter.t -> t
val add_list : t -> pair list -> t
val of_list : pair list -> t
val to_list : t -> pair list
diff --git a/dev/sidekick-base/Sidekick_base/Data_ty/Cstor/index.html b/dev/sidekick-base/Sidekick_base/Data_ty/Cstor/index.html index b828383b..d3692405 100644 --- a/dev/sidekick-base/Sidekick_base/Data_ty/Cstor/index.html +++ b/dev/sidekick-base/Sidekick_base/Data_ty/Cstor/index.html @@ -1,2 +1,2 @@ -Cstor (sidekick-base.Sidekick_base.Data_ty.Cstor)

Module Data_ty.Cstor

type t = cstor
val ty_args : t -> Types_.ty list
val select_idx : t -> int -> select
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Cstor (sidekick-base.Sidekick_base.Data_ty.Cstor)

Module Data_ty.Cstor

type t = cstor
val ty_args : t -> Types_.ty list
val select_idx : t -> int -> select
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/Data_ty/Select/index.html b/dev/sidekick-base/Sidekick_base/Data_ty/Select/index.html index ab3854bb..0c468443 100644 --- a/dev/sidekick-base/Sidekick_base/Data_ty/Select/index.html +++ b/dev/sidekick-base/Sidekick_base/Data_ty/Select/index.html @@ -1,2 +1,2 @@ -Select (sidekick-base.Sidekick_base.Data_ty.Select)

Module Data_ty.Select

type t = select
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Select (sidekick-base.Sidekick_base.Data_ty.Select)

Module Data_ty.Select

type t = select
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/Data_ty/index.html b/dev/sidekick-base/Sidekick_base/Data_ty/index.html index d2af97bf..ba3d229b 100644 --- a/dev/sidekick-base/Sidekick_base/Data_ty/index.html +++ b/dev/sidekick-base/Sidekick_base/Data_ty/index.html @@ -1,2 +1,2 @@ -Data_ty (sidekick-base.Sidekick_base.Data_ty)

Module Sidekick_base.Data_ty

type select = Types_.select = {
  1. select_id : ID.t;
  2. select_cstor : Types_.cstor;
  3. select_ty : Types_.ty lazy_t;
  4. select_i : int;
}
type cstor = Types_.cstor = {
  1. cstor_id : ID.t;
  2. cstor_is_a : ID.t;
  3. mutable cstor_arity : int;
  4. cstor_args : select list lazy_t;
  5. cstor_ty_as_data : Types_.data;
  6. cstor_ty : Types_.ty lazy_t;
}
type t = Types_.data = {
  1. data_id : ID.t;
  2. data_cstors : cstor Sidekick_base__.ID.Map.t lazy_t;
  3. data_as_ty : Types_.ty lazy_t;
}
type Sidekick_core.Const.view +=
  1. | Data of Types_.data
  2. | Cstor of cstor
  3. | Select of select
  4. | Is_a of cstor
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
module Select : sig ... end
module Cstor : sig ... end
val data_as_ty : t -> Types_.ty
val as_data : Types_.ty -> Types_.data option
val as_select : Types_.term -> select option
val as_cstor : Types_.term -> cstor option
val as_is_a : Types_.term -> cstor option
\ No newline at end of file +Data_ty (sidekick-base.Sidekick_base.Data_ty)

Module Sidekick_base.Data_ty

type select = Types_.select = {
  1. select_id : ID.t;
  2. select_cstor : Types_.cstor;
  3. select_ty : Types_.ty lazy_t;
  4. select_i : int;
}
type cstor = Types_.cstor = {
  1. cstor_id : ID.t;
  2. cstor_is_a : ID.t;
  3. mutable cstor_arity : int;
  4. cstor_args : select list lazy_t;
  5. cstor_ty_as_data : Types_.data;
  6. cstor_ty : Types_.ty lazy_t;
}
type t = Types_.data = {
  1. data_id : ID.t;
  2. data_cstors : cstor Sidekick_base__.ID.Map.t lazy_t;
  3. data_as_ty : Types_.ty lazy_t;
}
type Sidekick_core.Const.view +=
  1. | Data of Types_.data
  2. | Cstor of cstor
  3. | Select of select
  4. | Is_a of cstor
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
module Select : sig ... end
module Cstor : sig ... end
val data_as_ty : t -> Types_.ty
val as_data : Types_.ty -> Types_.data option
val as_select : Types_.term -> select option
val as_cstor : Types_.term -> cstor option
val as_is_a : Types_.term -> cstor option
diff --git a/dev/sidekick-base/Sidekick_base/Form/index.html b/dev/sidekick-base/Sidekick_base/Form/index.html index 3a075939..79cc3169 100644 --- a/dev/sidekick-base/Sidekick_base/Form/index.html +++ b/dev/sidekick-base/Sidekick_base/Form/index.html @@ -1,2 +1,2 @@ -Form (sidekick-base.Sidekick_base.Form)

Module Sidekick_base.Form

Formulas (boolean terms).

This module defines function symbols, constants, and views to manipulate boolean formulas in Sidekick_base. This is useful to have the ability to use boolean connectives instead of being limited to clauses; by using Sidekick_th_bool_static, the formulas are turned into clauses automatically for you.

type 'a view = 'a Sidekick_core.Bool_view.t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a
val view : term -> term view
val bool : Sidekick_core.Term.store -> bool -> term
val not_ : Sidekick_core.Term.store -> term -> term
val and_ : Sidekick_core.Term.store -> term -> term -> term
val or_ : Sidekick_core.Term.store -> term -> term -> term
val imply : Sidekick_core.Term.store -> term -> term -> term
val equiv : Sidekick_core.Term.store -> term -> term -> term
val distinct_l : Sidekick_core.Term.store -> term list -> term
val const_decoders : Sidekick_core.Const.decoders
val and_l : Sidekick_core.Term.store -> term list -> term
val or_l : Sidekick_core.Term.store -> term list -> term
val imply_l : Sidekick_core.Term.store -> term list -> term -> term
val mk_of_view : Sidekick_core.Term.store -> term view -> term
\ No newline at end of file +Form (sidekick-base.Sidekick_base.Form)

Module Sidekick_base.Form

Formulas (boolean terms).

This module defines function symbols, constants, and views to manipulate boolean formulas in Sidekick_base. This is useful to have the ability to use boolean connectives instead of being limited to clauses; by using Sidekick_th_bool_static, the formulas are turned into clauses automatically for you.

type 'a view = 'a Sidekick_core.Bool_view.t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a
val view : term -> term view
val bool : Sidekick_core.Term.store -> bool -> term
val not_ : Sidekick_core.Term.store -> term -> term
val and_ : Sidekick_core.Term.store -> term -> term -> term
val or_ : Sidekick_core.Term.store -> term -> term -> term
val imply : Sidekick_core.Term.store -> term -> term -> term
val equiv : Sidekick_core.Term.store -> term -> term -> term
val distinct_l : Sidekick_core.Term.store -> term list -> term
val const_decoders : Sidekick_core.Const.decoders
val and_l : Sidekick_core.Term.store -> term list -> term
val or_l : Sidekick_core.Term.store -> term list -> term
val imply_l : Sidekick_core.Term.store -> term list -> term -> term
val mk_of_view : Sidekick_core.Term.store -> term view -> term
diff --git a/dev/sidekick-base/Sidekick_base/ID/index.html b/dev/sidekick-base/Sidekick_base/ID/index.html index 589b8afd..9336af81 100644 --- a/dev/sidekick-base/Sidekick_base/ID/index.html +++ b/dev/sidekick-base/Sidekick_base/ID/index.html @@ -1,2 +1,2 @@ -ID (sidekick-base.Sidekick_base.ID)

Module Sidekick_base.ID

Unique Identifiers

We use generative identifiers everywhere in Sidekick_base. Unlike strings, there are no risk of collision: during parsing, a new declaration or definition should create a fresh ID.t and associate it with the string name, and later references should look into some hashtable or map to get the ID corresponding to a string.

This allows us to handle definition shadowing or binder shadowing easily.

type t

The opaque type of unique identifiers

val make : string -> t

make s creates a new identifier with name s and some internal information. It is different than any other identifier created before or after, even with the same name.

val makef : ('a, Stdlib.Format.formatter, unit, t) Stdlib.format4 -> 'a

makef "foo %d bar %b" 42 true is like make (Format.asprintf "foo %d bar %b" 42 true).

val copy : t -> t

Fresh copy of the identifier, distinct from it, but with the same name.

val id : t -> int

Unique integer counter for this identifier.

val to_string : t -> string

Print identifier.

val to_string_full : t -> string

Printer name and unique counter for this ID.

include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp_name : t CCFormat.printer
val pp_full : t CCFormat.printer
module Map : CCMap.S with type key = t
module Set : CCSet.S with type elt = t
module Tbl : CCHashtbl.S with type key = t
\ No newline at end of file +ID (sidekick-base.Sidekick_base.ID)

Module Sidekick_base.ID

Unique Identifiers

We use generative identifiers everywhere in Sidekick_base. Unlike strings, there are no risk of collision: during parsing, a new declaration or definition should create a fresh ID.t and associate it with the string name, and later references should look into some hashtable or map to get the ID corresponding to a string.

This allows us to handle definition shadowing or binder shadowing easily.

type t

The opaque type of unique identifiers

val make : string -> t

make s creates a new identifier with name s and some internal information. It is different than any other identifier created before or after, even with the same name.

val makef : ('a, Stdlib.Format.formatter, unit, t) Stdlib.format4 -> 'a

makef "foo %d bar %b" 42 true is like make (Format.asprintf "foo %d bar %b" 42 true).

val copy : t -> t

Fresh copy of the identifier, distinct from it, but with the same name.

val id : t -> int

Unique integer counter for this identifier.

val to_string : t -> string

Print identifier.

val to_string_full : t -> string

Printer name and unique counter for this ID.

include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp_name : t CCFormat.printer
val pp_full : t CCFormat.printer
module Map : CCMap.S with type key = t
module Set : CCSet.S with type elt = t
module Tbl : CCHashtbl.S with type key = t
diff --git a/dev/sidekick-base/Sidekick_base/LRA_term/Op/index.html b/dev/sidekick-base/Sidekick_base/LRA_term/Op/index.html index ea26264c..2c6927f5 100644 --- a/dev/sidekick-base/Sidekick_base/LRA_term/Op/index.html +++ b/dev/sidekick-base/Sidekick_base/LRA_term/Op/index.html @@ -1,2 +1,2 @@ -Op (sidekick-base.Sidekick_base.LRA_term.Op)

Module LRA_term.Op

type t = Sidekick_th_lra.op =
  1. | Plus
  2. | Minus
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Op (sidekick-base.Sidekick_base.LRA_term.Op)

Module LRA_term.Op

type t = Sidekick_th_lra.op =
  1. | Plus
  2. | Minus
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/LRA_term/Pred/index.html b/dev/sidekick-base/Sidekick_base/LRA_term/Pred/index.html index db71641c..34231d71 100644 --- a/dev/sidekick-base/Sidekick_base/LRA_term/Pred/index.html +++ b/dev/sidekick-base/Sidekick_base/LRA_term/Pred/index.html @@ -1,2 +1,2 @@ -Pred (sidekick-base.Sidekick_base.LRA_term.Pred)

Module LRA_term.Pred

type t = Sidekick_th_lra.Predicate.t =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Pred (sidekick-base.Sidekick_base.LRA_term.Pred)

Module LRA_term.Pred

type t = Sidekick_th_lra.Predicate.t =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/LRA_term/View/index.html b/dev/sidekick-base/Sidekick_base/LRA_term/View/index.html index 1f38e7f0..25be75ab 100644 --- a/dev/sidekick-base/Sidekick_base/LRA_term/View/index.html +++ b/dev/sidekick-base/Sidekick_base/LRA_term/View/index.html @@ -1,2 +1,2 @@ -View (sidekick-base.Sidekick_base.LRA_term.View)

Module LRA_term.View

type ('num, 'a) lra_view = ('num, 'a) Sidekick_th_lra.lra_view =
  1. | LRA_pred of Pred.t * 'a * 'a
  2. | LRA_op of Op.t * 'a * 'a
  3. | LRA_mult of 'num * 'a
  4. | LRA_const of 'num
  5. | LRA_other of 'a
type 'a t = (Q.t, 'a) Sidekick_th_lra.lra_view
val map : f_c:(Q.t -> Q.t) -> ('a -> 'b) -> 'a t -> 'b t
val iter : ('a -> unit) -> 'a t -> unit
val pp : pp_t:'a Sidekick_core.Fmt.printer -> 'a t Sidekick_core.Fmt.printer
val hash : sub_hash:('a -> int) -> 'a t -> int
val equal : sub_eq:('a -> 'b -> bool) -> 'a t -> 'b t -> bool
\ No newline at end of file +View (sidekick-base.Sidekick_base.LRA_term.View)

Module LRA_term.View

type ('num, 'a) lra_view = ('num, 'a) Sidekick_th_lra.lra_view =
  1. | LRA_pred of Pred.t * 'a * 'a
  2. | LRA_op of Op.t * 'a * 'a
  3. | LRA_mult of 'num * 'a
  4. | LRA_const of 'num
  5. | LRA_other of 'a
type 'a t = (Q.t, 'a) Sidekick_th_lra.lra_view
val map : f_c:(Q.t -> Q.t) -> ('a -> 'b) -> 'a t -> 'b t
val iter : ('a -> unit) -> 'a t -> unit
val pp : pp_t:'a Sidekick_core.Fmt.printer -> 'a t Sidekick_core.Fmt.printer
val hash : sub_hash:('a -> int) -> 'a t -> int
val equal : sub_eq:('a -> 'b -> bool) -> 'a t -> 'b t -> bool
diff --git a/dev/sidekick-base/Sidekick_base/LRA_term/index.html b/dev/sidekick-base/Sidekick_base/LRA_term/index.html index 0982c562..268d42e3 100644 --- a/dev/sidekick-base/Sidekick_base/LRA_term/index.html +++ b/dev/sidekick-base/Sidekick_base/LRA_term/index.html @@ -1,2 +1,2 @@ -LRA_term (sidekick-base.Sidekick_base.LRA_term)

Module Sidekick_base.LRA_term

module Pred : sig ... end
module Op : sig ... end
val const_decoders : Sidekick_core.Const.decoders
module View : sig ... end
val term_of_view : Sidekick_core.Term.store -> term View.t -> term
val has_ty_real : term -> bool
val mult_by : Sidekick_core.Term.store -> Q.t -> term -> term
val const : Sidekick_core.Term.store -> Q.t -> term

Helpers

val minus : Sidekick_core.Term.store -> term -> term -> term

View

val view : term -> term View.t

View as LRA

\ No newline at end of file +LRA_term (sidekick-base.Sidekick_base.LRA_term)

Module Sidekick_base.LRA_term

module Pred : sig ... end
module Op : sig ... end
val const_decoders : Sidekick_core.Const.decoders
module View : sig ... end
val term_of_view : Sidekick_core.Term.store -> term View.t -> term
val has_ty_real : term -> bool
val mult_by : Sidekick_core.Term.store -> Q.t -> term -> term
val const : Sidekick_core.Term.store -> Q.t -> term

Helpers

val minus : Sidekick_core.Term.store -> term -> term -> term

View

val view : term -> term View.t

View as LRA

diff --git a/dev/sidekick-base/Sidekick_base/Solver/index.html b/dev/sidekick-base/Sidekick_base/Solver/index.html index 36b1e854..eaccd1fa 100644 --- a/dev/sidekick-base/Sidekick_base/Solver/index.html +++ b/dev/sidekick-base/Sidekick_base/Solver/index.html @@ -1,24 +1,24 @@ -Solver (sidekick-base.Sidekick_base.Solver)

Module Sidekick_base.Solver

include module type of struct include Sidekick_smt_solver.Solver end

The solver's state.

A solver contains a registry so that theories can share data

val mk_theory : - name:string -> - create_and_setup: - (id:Sidekick_smt_solver.Theory_id.t -> +Solver (sidekick-base.Sidekick_base.Solver)

Module Sidekick_base.Solver

include module type of struct include Sidekick_smt_solver.Solver end

The solver's state.

A solver contains a registry so that theories can share data

val mk_theory : + name:string -> + create_and_setup: + (id:Sidekick_smt_solver.Theory_id.t -> Sidekick_smt_solver.Solver_internal.t -> 'th) -> - ?push_level:('th -> unit) -> - ?pop_levels:('th -> int -> unit) -> + ?push_level:('th -> unit) -> + ?pop_levels:('th -> int -> unit) -> unit -> Sidekick_smt_solver.Theory.t

Helper to create a theory.

Main API

val stats : t -> Sidekick_util.Stat.t
val create : (module Sidekick_smt_solver.Sigs.ARG) -> - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Big | `Tiny | `Small ] -> - tracer:Sidekick_smt_solver.Tracer.t -> - theories:Sidekick_smt_solver.Theory.t list -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Big | `Tiny | `Small ] -> + tracer:Sidekick_smt_solver.Tracer.t -> + theories:Sidekick_smt_solver.Theory.t list -> Sidekick_core.Term.store -> unit -> t

Create a new solver.

It needs a term state and a type state to manipulate terms and types. All terms and types interacting with this solver will need to come from these exact states.

  • parameter store_proof

    if true, proofs from the SAT solver and theories are retained and potentially accessible after solve returns UNSAT.

  • parameter size

    influences the size of initial allocations.

  • parameter theories

    theories to load from the start. Other theories can be added using add_theory.

val add_theory : t -> Sidekick_smt_solver.Theory.t -> unit

Add a theory to the solver. This should be called before any call to solve or to add_clause and the likes (otherwise the theory will have a partial view of the problem).

val add_theory_p : t -> 'a Sidekick_smt_solver.Theory.p -> 'a

Add the given theory and obtain its state

val add_theory_l : t -> Sidekick_smt_solver.Theory.t list -> unit
val mk_lit_t : t -> - ?sign:bool -> + ?sign:bool -> Sidekick_smt_solver.Sigs.term -> Sidekick_smt_solver.Sigs.lit

mk_lit_t _ ~sign t returns lit', where lit' is preprocess(lit) and lit is an internal representation of ± t.

The proof of |- lit = lit' is directly added to the solver's proof.

val add_clause : t -> @@ -29,18 +29,18 @@ Sidekick_smt_solver.Sigs.lit list -> Sidekick_proof.Pterm.delayed -> unit

Add a clause to the solver, given as a list.

val assert_terms : t -> Sidekick_smt_solver.Sigs.term list -> unit

Helper that turns each term into an atom, before adding disjunction of the resulting atoms to the solver as a clause assertion

val assert_term : t -> Sidekick_smt_solver.Sigs.term -> unit

Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion

val add_ty : t -> Sidekick_smt_solver.Sigs.ty -> unit
type sat_result = Check_res.sat_result = {
  1. get_value : Sidekick_core.Term.t -> value option;
    (*

    Value for this term

    *)
  2. iter_classes : (Sidekick_core.Term.t Iter.t * value) Iter.t;
    (*

    All equivalence classes in the congruence closure

    *)
  3. eval_lit : Sidekick_core.Lit.t -> bool option;
    (*

    Evaluate literal

    *)
  4. iter_true_lits : Sidekick_core.Lit.t Iter.t;
    (*

    Iterate on literals that are true in the trail

    *)
}

Satisfiable

type unsat_result = Check_res.unsat_result = {
  1. unsat_core : unit -> Sidekick_core.Lit.t Iter.t;
    (*

    Unsat core (subset of assumptions), or empty

    *)
  2. unsat_proof : unit -> Sidekick_proof.Step.id option;
    (*

    Proof step for the empty clause

    *)
}

Unsatisfiable

type res = Check_res.t =
  1. | Sat of sat_result
  2. | Unsat of unsat_result
  3. | Unknown of Unknown.t
    (*

    Unknown, obtained after a timeout, memory limit, etc.

    *)

Result of solving for the current set of clauses

val solve : - ?on_exit:(unit -> unit) list -> - ?on_progress:(unit -> unit) -> - ?should_stop:(int -> bool) -> - assumptions:Sidekick_smt_solver.Sigs.lit list -> + ?on_exit:(unit -> unit) list -> + ?on_progress:(unit -> unit) -> + ?should_stop:(int -> bool) -> + assumptions:Sidekick_smt_solver.Sigs.lit list -> t -> res

solve s checks the satisfiability of the clauses added so far to s.

  • parameter on_progress

    called regularly during solving.

  • parameter assumptions

    a set of atoms held to be true. The unsat core, if any, will be a subset of assumptions.

  • parameter should_stop

    a callback regularly called from within the solver. It is given a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

Comply to the abstract solver interface

val last_res : t -> res option

Last result, if any. Some operations will erase this (e.g. assert_term).

val push_assumption : t -> Sidekick_smt_solver.Sigs.lit -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions. Note that check_sat_propagations_only can call this if it meets a conflict.

type propagation_result = Sidekick_smt_solver.Solver.propagation_result =
  1. | PR_sat
  2. | PR_conflict of {
    1. backtracked : int;
    }
  3. | PR_unsat of {
    1. unsat_core : unit -> Sidekick_smt_solver.Sigs.lit Iter.t;
    }
val check_sat_propagations_only : - assumptions:Sidekick_smt_solver.Sigs.lit list -> + assumptions:Sidekick_smt_solver.Sigs.lit list -> t -> propagation_result

check_sat_propagations_only solver uses assumptions (including the assumptions parameter, and atoms previously added via push_assumptions) and boolean+theory propagation to quickly assess satisfiability. It is not complete; calling solve is required to get an accurate result.

  • returns

    one of:

    • PR_sat if the current state seems satisfiable
    • PR_conflict {backtracked=n} if a conflict was found and resolved, leading to backtracking n levels of assumptions
    • PR_unsat … if the assumptions were found to be unsatisfiable, with the given core.
val pp_stats : t CCFormat.printer

Print some statistics. What it prints exactly is unspecified.

val default_arg : (module Sidekick_smt_solver.Sigs.ARG)
val create_default : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Big | `Small | `Tiny ] -> - tracer:Sidekick_smt_solver.Tracer.t -> - theories:Sidekick_smt_solver.Theory.t list -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Big | `Small | `Tiny ] -> + tracer:Sidekick_smt_solver.Tracer.t -> + theories:Sidekick_smt_solver.Theory.t list -> Sidekick_core.Term.store -> - t
\ No newline at end of file + t
diff --git a/dev/sidekick-base/Sidekick_base/Statement/index.html b/dev/sidekick-base/Sidekick_base/Statement/index.html index d14194d3..8b26b56f 100644 --- a/dev/sidekick-base/Sidekick_base/Statement/index.html +++ b/dev/sidekick-base/Sidekick_base/Statement/index.html @@ -1,2 +1,2 @@ -Statement (sidekick-base.Sidekick_base.Statement)

Module Sidekick_base.Statement

Statements.

A statement is an instruction for the SMT solver to do something, like asserting that a formula is true, declaring a new constant, or checking satisfiabilty of the current set of assertions.

type t = Types_.statement =
  1. | Stmt_set_logic of string
  2. | Stmt_set_option of string list
  3. | Stmt_set_info of string * string
  4. | Stmt_data of Types_.data list
  5. | Stmt_ty_decl of {
    1. name : ID.t;
    2. arity : int;
    3. ty_const : Types_.ty;
    }
    (*

    new atomic cstor

    *)
  6. | Stmt_decl of {
    1. name : ID.t;
    2. ty_args : Types_.ty list;
    3. ty_ret : Types_.ty;
    4. const : Types_.term;
    }
  7. | Stmt_define of Types_.definition list
  8. | Stmt_assert of Types_.term
  9. | Stmt_assert_clause of Types_.term list
  10. | Stmt_check_sat of (bool * Types_.term) list
  11. | Stmt_get_model
  12. | Stmt_get_value of Types_.term list
  13. | Stmt_exit
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Statement (sidekick-base.Sidekick_base.Statement)

Module Sidekick_base.Statement

Statements.

A statement is an instruction for the SMT solver to do something, like asserting that a formula is true, declaring a new constant, or checking satisfiabilty of the current set of assertions.

type t = Types_.statement =
  1. | Stmt_set_logic of string
  2. | Stmt_set_option of string list
  3. | Stmt_set_info of string * string
  4. | Stmt_data of Types_.data list
  5. | Stmt_ty_decl of {
    1. name : ID.t;
    2. arity : int;
    3. ty_const : Types_.ty;
    }
    (*

    new atomic cstor

    *)
  6. | Stmt_decl of {
    1. name : ID.t;
    2. ty_args : Types_.ty list;
    3. ty_ret : Types_.ty;
    4. const : Types_.term;
    }
  7. | Stmt_define of Types_.definition list
  8. | Stmt_assert of Types_.term
  9. | Stmt_assert_clause of Types_.term list
  10. | Stmt_check_sat of (bool * Types_.term) list
  11. | Stmt_get_model
  12. | Stmt_get_value of Types_.term list
  13. | Stmt_exit
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/Term/index.html b/dev/sidekick-base/Sidekick_base/Term/index.html index 21a4ded2..2a9f6e68 100644 --- a/dev/sidekick-base/Sidekick_base/Term/index.html +++ b/dev/sidekick-base/Sidekick_base/Term/index.html @@ -1,14 +1,14 @@ -Term (sidekick-base.Sidekick_base.Term)

Module Sidekick_base.Term

include module type of struct include Sidekick_core.Term end
include module type of struct include Sidekick_core_logic.Term end
type t

A term, in the calculus of constructions

The store for terms.

The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).

type view =
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_lam of string * t * t
  6. | E_pi of string * t * t

View.

A view is the shape of the root node of a term.

include Sidekick_sigs.EQ_ORD_HASH with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer

Containers

include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
include Sidekick_sigs.WITH_WEAK with type t := t
module Weak_set = Sidekick_core.Term.Weak_set
module Weak_map = Sidekick_core.Term.Weak_map

Utils

val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> unit

iter_dag t ~f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.

For example, in:

let x = 2 in
+Term (sidekick-base.Sidekick_base.Term)
Module Sidekick_base.Term
include module type of struct include Sidekick_core.Term end
include module type of struct include Sidekick_core_logic.Term end
type t
A term, in the calculus of constructions
The store for terms.
The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
type view = 
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_lam of string * t * t
  6. | E_pi of string * t * t
View.
A view is the shape of the root node of a term.
include Sidekick_sigs.EQ_ORD_HASH with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer
Containers
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
include Sidekick_sigs.WITH_WEAK with type t := t
module Weak_set = Sidekick_core.Term.Weak_set
module Weak_map = Sidekick_core.Term.Weak_map
Utils
val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> unit
iter_dag t ~f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.
For example, in:
let x = 2 in
 let y = f x x in
 let z = g y x in
 z = z
the DAG has the following nodes:
n1: 2
 n2: f n1 n1
 n3: g n2 n1
-n4: = n3 n3
val iter_shallow : f:(bool -> t -> unit) -> t -> unit
iter_shallow f e iterates on immediate subterms of e, calling f trdb e' for each subterm e', with trdb = true iff e' is directly under a binder.
val map_shallow : store -> f:(bool -> t -> t) -> t -> t
val exists_shallow : f:(bool -> t -> bool) -> t -> bool
val for_all_shallow : f:(bool -> t -> bool) -> t -> bool
val contains : t -> sub:t -> bool
val free_vars_iter : t -> var Iter.t
val free_vars : 
-  ?init:Sidekick_core_logic__.Var.Set.t ->
+n4: = n3 n3
val iter_shallow : f:(bool -> t -> unit) -> t -> unit

iter_shallow f e iterates on immediate subterms of e, calling f trdb e' for each subterm e', with trdb = true iff e' is directly under a binder.

val map_shallow : store -> f:(bool -> t -> t) -> t -> t
val exists_shallow : f:(bool -> t -> bool) -> t -> bool
val for_all_shallow : f:(bool -> t -> bool) -> t -> bool
val contains : t -> sub:t -> bool
val free_vars_iter : t -> var Iter.t
val free_vars : + ?init:Sidekick_core_logic__.Var.Set.t -> t -> - Sidekick_core_logic__.Var.Set.t
val is_type : t -> bool

is_type t is true iff view t is Type _

val is_a_type : t -> bool

is_a_type t is true if is_ty (ty t)

val is_closed : t -> bool

Is the term closed (all bound variables are paired with a binder)? time: O(1)

val has_fvars : t -> bool

Does the term contain free variables? time: O(1)

val ty : t -> t

Return the type of this term.

Creation

val type_ : store -> t
val type_of_univ : store -> int -> t
val var : store -> var -> t
val var_str : store -> string -> ty:t -> t
val bvar : store -> bvar -> t
val bvar_i : store -> int -> ty:t -> t
val const : store -> Sidekick_core_logic__.Types_.const -> t
val app : store -> t -> t -> t
val app_l : store -> t -> t list -> t
val app_fold : store -> f:t -> acc0:t -> t list -> t
val lam : store -> var -> t -> t
val pi : store -> var -> t -> t
val arrow : store -> t -> t -> t
val arrow_l : store -> t list -> t -> t
val open_lambda : store -> t -> (var * t) option
val open_lambda_exn : store -> t -> var * t

De bruijn indices

include module type of struct include Sidekick_core_logic.T_builtins end
type Sidekick_core_logic__.Types_.const_view +=
  1. | C_bool
  2. | C_eq
  3. | C_ite
  4. | C_not
  5. | C_true
  6. | C_false
  7. | C_proof
val true_ : Sidekick_core_logic.Term.store -> Sidekick_core_logic.Term.t
val false_ : Sidekick_core_logic.Term.store -> Sidekick_core_logic.Term.t
val bool_val : + Sidekick_core_logic__.Var.Set.t
val is_type : t -> bool

is_type t is true iff view t is Type _

val is_a_type : t -> bool

is_a_type t is true if is_ty (ty t)

val is_closed : t -> bool

Is the term closed (all bound variables are paired with a binder)? time: O(1)

val has_fvars : t -> bool

Does the term contain free variables? time: O(1)

val ty : t -> t

Return the type of this term.

Creation

val type_ : store -> t
val type_of_univ : store -> int -> t
val var : store -> var -> t
val var_str : store -> string -> ty:t -> t
val bvar : store -> bvar -> t
val bvar_i : store -> int -> ty:t -> t
val const : store -> Sidekick_core_logic__.Types_.const -> t
val app : store -> t -> t -> t
val app_l : store -> t -> t list -> t
val app_fold : store -> f:t -> acc0:t -> t list -> t
val lam : store -> var -> t -> t
val pi : store -> var -> t -> t
val arrow : store -> t -> t -> t
val arrow_l : store -> t list -> t -> t
val open_lambda : store -> t -> (var * t) option
val open_lambda_exn : store -> t -> var * t

De bruijn indices

include module type of struct include Sidekick_core_logic.T_builtins end
type Sidekick_core_logic__.Types_.const_view +=
  1. | C_bool
  2. | C_eq
  3. | C_ite
  4. | C_not
  5. | C_true
  6. | C_false
  7. | C_proof
val true_ : Sidekick_core_logic.Term.store -> Sidekick_core_logic.Term.t
val false_ : Sidekick_core_logic.Term.store -> Sidekick_core_logic.Term.t
val eq : @@ -29,12 +29,12 @@ n4: = n3 n3
Sidekick_core_logic.Term.t

abs t returns an "absolute value" for the term, along with the sign of t.

The idea is that we want to turn not a into (false, a), or (a != b) into (false, a=b). For terms without a negation this should return (true, t).

val as_bool_val : Sidekick_core_logic.Term.t -> bool option

open_eq (a=b) returns Some (a,b), None for other terms.

type hook = - recurse:term Sidekick_util.Fmt.printer -> + recurse:term Sidekick_util.Fmt.printer -> Sidekick_util.Fmt.t -> term -> - bool

Printing hook, responsible for printing certain subterms

val default_hooks : Hooks.t Stdlib.ref
val pp_with : Hooks.t -> term Sidekick_util.Fmt.printer

Print using the hooks

val pp : term Sidekick_util.Fmt.printer

Print using default_hooks

val pp_limit : max_depth:int -> max_nodes:int -> term Sidekick_util.Fmt.printer

Print with a limit on the number of nodes printed. An ellipsis is displayed otherwise.

module Trace_reader = Sidekick_core.Term.Trace_reader
val view_as_cc : + bool

Printing hook, responsible for printing certain subterms

val default_hooks : Hooks.t Stdlib.ref
val pp_with : Hooks.t -> term Sidekick_util.Fmt.printer

Print using the hooks

val pp : term Sidekick_util.Fmt.printer

Print using default_hooks

val pp_limit : max_depth:int -> max_nodes:int -> term Sidekick_util.Fmt.printer

Print with a limit on the number of nodes printed. An ellipsis is displayed otherwise.

module Trace_reader = Sidekick_core.Term.Trace_reader
\ No newline at end of file + Sidekick_core.CC_view.t diff --git a/dev/sidekick-base/Sidekick_base/Th_bool/index.html b/dev/sidekick-base/Sidekick_base/Th_bool/index.html index 5e65ebd4..da64fac8 100644 --- a/dev/sidekick-base/Sidekick_base/Th_bool/index.html +++ b/dev/sidekick-base/Sidekick_base/Th_bool/index.html @@ -1,2 +1,2 @@ -Th_bool (sidekick-base.Sidekick_base.Th_bool)

Module Sidekick_base.Th_bool

Reducing boolean formulas to clauses

val k_config : [ `Dyn | `Static ] Config.Key.t
val theory_static : Solver.theory
val theory_dyn : Solver.theory
val theory : Config.t -> Solver.theory
\ No newline at end of file +Th_bool (sidekick-base.Sidekick_base.Th_bool)

Module Sidekick_base.Th_bool

Reducing boolean formulas to clauses

val k_config : [ `Dyn | `Static ] Config.Key.t
val theory_static : Solver.theory
val theory_dyn : Solver.theory
val theory : Config.t -> Solver.theory
diff --git a/dev/sidekick-base/Sidekick_base/Th_data/index.html b/dev/sidekick-base/Sidekick_base/Th_data/index.html index a4cc439a..95a30dc1 100644 --- a/dev/sidekick-base/Sidekick_base/Th_data/index.html +++ b/dev/sidekick-base/Sidekick_base/Th_data/index.html @@ -1,2 +1,2 @@ -Th_data (sidekick-base.Sidekick_base.Th_data)

Module Sidekick_base.Th_data

Theory of datatypes

val arg : (module Sidekick_th_data.ARG)
\ No newline at end of file +Th_data (sidekick-base.Sidekick_base.Th_data)

Module Sidekick_base.Th_data

Theory of datatypes

val arg : (module Sidekick_th_data.ARG)
diff --git a/dev/sidekick-base/Sidekick_base/Th_lra/index.html b/dev/sidekick-base/Sidekick_base/Th_lra/index.html index f300761b..6209c0bc 100644 --- a/dev/sidekick-base/Sidekick_base/Th_lra/index.html +++ b/dev/sidekick-base/Sidekick_base/Th_lra/index.html @@ -1,2 +1,2 @@ -Th_lra (sidekick-base.Sidekick_base.Th_lra)

Module Sidekick_base.Th_lra

Theory of Linear Rational Arithmetic

val theory : Solver.theory
\ No newline at end of file +Th_lra (sidekick-base.Sidekick_base.Th_lra)

Module Sidekick_base.Th_lra

Theory of Linear Rational Arithmetic

val theory : Solver.theory
diff --git a/dev/sidekick-base/Sidekick_base/Th_ty_unin/index.html b/dev/sidekick-base/Sidekick_base/Th_ty_unin/index.html index faa7882a..ade219c4 100644 --- a/dev/sidekick-base/Sidekick_base/Th_ty_unin/index.html +++ b/dev/sidekick-base/Sidekick_base/Th_ty_unin/index.html @@ -1,2 +1,2 @@ -Th_ty_unin (sidekick-base.Sidekick_base.Th_ty_unin)

Module Sidekick_base.Th_ty_unin

val theory : Solver.theory
\ No newline at end of file +Th_ty_unin (sidekick-base.Sidekick_base.Th_ty_unin)

Module Sidekick_base.Th_ty_unin

val theory : Solver.theory
diff --git a/dev/sidekick-base/Sidekick_base/Ty/index.html b/dev/sidekick-base/Sidekick_base/Ty/index.html index e7ab43f0..03d76698 100644 --- a/dev/sidekick-base/Sidekick_base/Ty/index.html +++ b/dev/sidekick-base/Sidekick_base/Ty/index.html @@ -1,14 +1,14 @@ -Ty (sidekick-base.Sidekick_base.Ty)

Module Sidekick_base.Ty

include module type of struct include Sidekick_core.Term end
include module type of struct include Sidekick_core_logic.Term end

The store for terms.

The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).

type view =
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar

View.

A view is the shape of the root node of a term.

include Sidekick_sigs.EQ_ORD_HASH +Ty (sidekick-base.Sidekick_base.Ty)

Module Sidekick_base.Ty

include module type of struct include Sidekick_core.Term end
include module type of struct include Sidekick_core_logic.Term end

The store for terms.

The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).

type view =
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar

View.

A view is the shape of the root node of a term.

include Sidekick_sigs.EQ_ORD_HASH with type t := Sidekick_core_logic__.Types_.term
include Sidekick_sigs.EQ with type t := Sidekick_core_logic__.Types_.term
include Sidekick_sigs.ORD with type t := Sidekick_core_logic__.Types_.term
include Sidekick_sigs.HASH with type t := Sidekick_core_logic__.Types_.term
val pp_debug : Sidekick_core_logic__.Types_.term Sidekick_util.Fmt.printer
val pp_debug_with_ids : Sidekick_core_logic__.Types_.term Sidekick_util.Fmt.printer

Containers

include Sidekick_sigs.WITH_SET_MAP_TBL with type t := Sidekick_core_logic__.Types_.term
include Sidekick_sigs.WITH_WEAK with type t := Sidekick_core_logic__.Types_.term
module Weak_set = Sidekick_core.Term.Weak_set
module Weak_map = Sidekick_core.Term.Weak_map

Utils

val view : Sidekick_core_logic__.Types_.term -> view
val unfold_app : Sidekick_core_logic__.Types_.term -> Sidekick_core_logic__.Types_.term * Sidekick_core_logic__.Types_.term list
val is_app : Sidekick_core_logic__.Types_.term -> bool
val is_const : Sidekick_core_logic__.Types_.term -> bool
val is_pi : Sidekick_core_logic__.Types_.term -> bool
val iter_dag : - ?seen:unit Tbl.t -> - iter_ty:bool -> - f:(Sidekick_core_logic__.Types_.term -> unit) -> + ?seen:unit Tbl.t -> + iter_ty:bool -> + f:(Sidekick_core_logic__.Types_.term -> unit) -> Sidekick_core_logic__.Types_.term -> unit

iter_dag t ~f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.

For example, in:

let x = 2 in
 let y = f x x in
@@ -17,35 +17,35 @@ z = z

the DAG has the following nodes:

val iter_shallow : 
-  f:(bool -> Sidekick_core_logic__.Types_.term -> unit) ->
+  f:(bool -> Sidekick_core_logic__.Types_.term -> unit) ->
   Sidekick_core_logic__.Types_.term ->
   unit
iter_shallow f e iterates on immediate subterms of e, calling f trdb e' for each subterm e', with trdb = true iff e' is directly under a binder.
val map_shallow : store -> - f: + f: (bool -> Sidekick_core_logic__.Types_.term -> Sidekick_core_logic__.Types_.term) -> Sidekick_core_logic__.Types_.term -> Sidekick_core_logic__.Types_.term
val exists_shallow : - f:(bool -> Sidekick_core_logic__.Types_.term -> bool) -> + f:(bool -> Sidekick_core_logic__.Types_.term -> bool) -> Sidekick_core_logic__.Types_.term -> bool
val for_all_shallow : - f:(bool -> Sidekick_core_logic__.Types_.term -> bool) -> + f:(bool -> Sidekick_core_logic__.Types_.term -> bool) -> Sidekick_core_logic__.Types_.term -> bool
val contains : Sidekick_core_logic__.Types_.term -> - sub:Sidekick_core_logic__.Types_.term -> + sub:Sidekick_core_logic__.Types_.term -> bool
val free_vars_iter : Sidekick_core_logic__.Types_.term -> var Iter.t
val free_vars : - ?init:Sidekick_core_logic__.Var.Set.t -> + ?init:Sidekick_core_logic__.Var.Set.t -> Sidekick_core_logic__.Types_.term -> Sidekick_core_logic__.Var.Set.t
val is_type : Sidekick_core_logic__.Types_.term -> bool

is_type t is true iff view t is Type _

val is_a_type : Sidekick_core_logic__.Types_.term -> bool

is_a_type t is true if is_ty (ty t)

val is_closed : Sidekick_core_logic__.Types_.term -> bool

Is the term closed (all bound variables are paired with a binder)? time: O(1)

val has_fvars : Sidekick_core_logic__.Types_.term -> bool

Does the term contain free variables? time: O(1)

val ty : Sidekick_core_logic__.Types_.term -> Sidekick_core_logic__.Types_.term

Return the type of this term.

Creation

val type_ : store -> Sidekick_core_logic__.Types_.term
val type_of_univ : store -> int -> Sidekick_core_logic__.Types_.term
val var : store -> var -> Sidekick_core_logic__.Types_.term
val var_str : store -> string -> - ty:Sidekick_core_logic__.Types_.term -> + ty:Sidekick_core_logic__.Types_.term -> Sidekick_core_logic__.Types_.term
val bvar : store -> bvar -> Sidekick_core_logic__.Types_.term
val bvar_i : store -> int -> - ty:Sidekick_core_logic__.Types_.term -> + ty:Sidekick_core_logic__.Types_.term -> Sidekick_core_logic__.Types_.term
val const : store -> Sidekick_core_logic__.Types_.const -> @@ -59,8 +59,8 @@ n4: = n3 n3
Sidekick_core_logic__.Types_.term list -> Sidekick_core_logic__.Types_.term
val app_fold : store -> - f:Sidekick_core_logic__.Types_.term -> - acc0:Sidekick_core_logic__.Types_.term -> + f:Sidekick_core_logic__.Types_.term -> + acc0:Sidekick_core_logic__.Types_.term -> Sidekick_core_logic__.Types_.term list -> Sidekick_core_logic__.Types_.term
val lam : store -> @@ -105,7 +105,7 @@ n4: = n3 n3
Sidekick_core_logic.Term.t

abs t returns an "absolute value" for the term, along with the sign of t.

The idea is that we want to turn not a into (false, a), or (a != b) into (false, a=b). For terms without a negation this should return (true, t).

val as_bool_val : Sidekick_core_logic.Term.t -> bool option

open_eq (a=b) returns Some (a,b), None for other terms.

type hook = - recurse:term Sidekick_util.Fmt.printer -> + recurse:term Sidekick_util.Fmt.printer -> Sidekick_util.Fmt.t -> term -> - bool

Printing hook, responsible for printing certain subterms

val default_hooks : Hooks.t Stdlib.ref
val pp_with : Hooks.t -> term Sidekick_util.Fmt.printer

Print using the hooks

val pp_limit : max_depth:int -> max_nodes:int -> term Sidekick_util.Fmt.printer

Print with a limit on the number of nodes printed. An ellipsis is displayed otherwise.

module Trace_reader = Sidekick_core.Term.Trace_reader
type t = Types_.ty
type data = Types_.data
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val const_decoders : Sidekick_core.Const.decoders
val bool : store -> t
val real : store -> t
val int : store -> t
val uninterpreted : store -> ID.t -> t
val uninterpreted_str : store -> string -> t
val is_uninterpreted : t -> bool
val is_real : t -> bool
val is_int : t -> bool
\ No newline at end of file + bool

Printing hook, responsible for printing certain subterms

val default_hooks : Hooks.t Stdlib.ref
val pp_with : Hooks.t -> term Sidekick_util.Fmt.printer

Print using the hooks

val pp_limit : max_depth:int -> max_nodes:int -> term Sidekick_util.Fmt.printer

Print with a limit on the number of nodes printed. An ellipsis is displayed otherwise.

module Trace_reader = Sidekick_core.Term.Trace_reader
type t = Types_.ty
type data = Types_.data
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val const_decoders : Sidekick_core.Const.decoders
val bool : store -> t
val real : store -> t
val int : store -> t
val uninterpreted : store -> ID.t -> t
val uninterpreted_str : store -> string -> t
val is_uninterpreted : t -> bool
val is_real : t -> bool
val is_int : t -> bool
diff --git a/dev/sidekick-base/Sidekick_base/Types_/index.html b/dev/sidekick-base/Sidekick_base/Types_/index.html index 8de96190..8ebe3580 100644 --- a/dev/sidekick-base/Sidekick_base/Types_/index.html +++ b/dev/sidekick-base/Sidekick_base/Types_/index.html @@ -1,7 +1,7 @@ -Types_ (sidekick-base.Sidekick_base.Types_)

Module Sidekick_base.Types_

include module type of struct include Sidekick_core end
module Fmt = Sidekick_core.Fmt

Re-exports from core-logic

module Const = Sidekick_core.Const
module Str_const = Sidekick_core.Str_const
module Term = Sidekick_core.Term

view

module Bool_view = Sidekick_core.Bool_view
module CC_view = Sidekick_core.CC_view
module Default_cc_view = Sidekick_core.Default_cc_view

Main modules

module Bvar = Sidekick_core.Bvar
module Lit = Sidekick_core.Lit
module Subst = Sidekick_core.Subst
module Var = Sidekick_core.Var
module Box = Sidekick_core.Box
module Gensym = Sidekick_core.Gensym
exception Resource_exhausted

Const decoders for traces

val const_decoders : +Types_ (sidekick-base.Sidekick_base.Types_)

Module Sidekick_base.Types_

include module type of struct include Sidekick_core end
module Fmt = Sidekick_core.Fmt

Re-exports from core-logic

module Const = Sidekick_core.Const
module Str_const = Sidekick_core.Str_const
module Term = Sidekick_core.Term

view

module Bool_view = Sidekick_core.Bool_view
module CC_view = Sidekick_core.CC_view
module Default_cc_view = Sidekick_core.Default_cc_view

Main modules

module Bvar = Sidekick_core.Bvar
module Lit = Sidekick_core.Lit
module Subst = Sidekick_core.Subst
module Var = Sidekick_core.Var
module Box = Sidekick_core.Box
module Gensym = Sidekick_core.Gensym
exception Resource_exhausted

Const decoders for traces

val const_decoders : (string * Sidekick_core_logic.Const.Ops.t * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t -> Sidekick_core_logic.Const.view Sidekick_util.Ser_decode.t)) - list
type term = Term.t
type ty = Term.t
type value = Term.t
type uconst = {
  1. uc_id : ID.t;
  2. uc_ty : ty;
}

Uninterpreted constant.

type ty_view =
  1. | Ty_int
  2. | Ty_real
  3. | Ty_uninterpreted of {
    1. id : ID.t;
    2. mutable finite : bool;
    }
and data = {
  1. data_id : ID.t;
  2. data_cstors : cstor Sidekick_base__.ID.Map.t lazy_t;
  3. data_as_ty : ty lazy_t;
}
and cstor = {
  1. cstor_id : ID.t;
  2. cstor_is_a : ID.t;
  3. mutable cstor_arity : int;
  4. cstor_args : select list lazy_t;
  5. cstor_ty_as_data : data;
  6. cstor_ty : ty lazy_t;
}
and select = {
  1. select_id : ID.t;
  2. select_cstor : cstor;
  3. select_ty : ty lazy_t;
  4. select_i : int;
}
type definition = ID.t * ty * term
type statement =
  1. | Stmt_set_logic of string
  2. | Stmt_set_option of string list
  3. | Stmt_set_info of string * string
  4. | Stmt_data of data list
  5. | Stmt_ty_decl of {
    1. name : ID.t;
    2. arity : int;
    3. ty_const : ty;
    }
    (*

    new atomic cstor

    *)
  6. | Stmt_decl of {
    1. name : ID.t;
    2. ty_args : ty list;
    3. ty_ret : ty;
    4. const : term;
    }
  7. | Stmt_define of definition list
  8. | Stmt_assert of term
  9. | Stmt_assert_clause of term list
  10. | Stmt_check_sat of (bool * term) list
  11. | Stmt_get_model
  12. | Stmt_get_value of term list
  13. | Stmt_exit
\ No newline at end of file + list
type term = Term.t
type ty = Term.t
type value = Term.t
type uconst = {
  1. uc_id : ID.t;
  2. uc_ty : ty;
}

Uninterpreted constant.

type ty_view =
  1. | Ty_int
  2. | Ty_real
  3. | Ty_uninterpreted of {
    1. id : ID.t;
    2. mutable finite : bool;
    }
and data = {
  1. data_id : ID.t;
  2. data_cstors : cstor Sidekick_base__.ID.Map.t lazy_t;
  3. data_as_ty : ty lazy_t;
}
and cstor = {
  1. cstor_id : ID.t;
  2. cstor_is_a : ID.t;
  3. mutable cstor_arity : int;
  4. cstor_args : select list lazy_t;
  5. cstor_ty_as_data : data;
  6. cstor_ty : ty lazy_t;
}
and select = {
  1. select_id : ID.t;
  2. select_cstor : cstor;
  3. select_ty : ty lazy_t;
  4. select_i : int;
}
type definition = ID.t * ty * term
type statement =
  1. | Stmt_set_logic of string
  2. | Stmt_set_option of string list
  3. | Stmt_set_info of string * string
  4. | Stmt_data of data list
  5. | Stmt_ty_decl of {
    1. name : ID.t;
    2. arity : int;
    3. ty_const : ty;
    }
    (*

    new atomic cstor

    *)
  6. | Stmt_decl of {
    1. name : ID.t;
    2. ty_args : ty list;
    3. ty_ret : ty;
    4. const : term;
    }
  7. | Stmt_define of definition list
  8. | Stmt_assert of term
  9. | Stmt_assert_clause of term list
  10. | Stmt_check_sat of (bool * term) list
  11. | Stmt_get_model
  12. | Stmt_get_value of term list
  13. | Stmt_exit
diff --git a/dev/sidekick-base/Sidekick_base/Uconst/index.html b/dev/sidekick-base/Sidekick_base/Uconst/index.html index 64f98194..af7e1038 100644 --- a/dev/sidekick-base/Sidekick_base/Uconst/index.html +++ b/dev/sidekick-base/Sidekick_base/Uconst/index.html @@ -1,5 +1,5 @@ -Uconst (sidekick-base.Sidekick_base.Uconst)

Module Sidekick_base.Uconst

Uninterpreted constants

type t = Types_.uconst = {
  1. uc_id : ID.t;
  2. uc_ty : ty;
}
val id : t -> ID.t
val ty : t -> ty
type Sidekick_core.Const.view +=
  1. | Uconst of t
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val const_decoders : Sidekick_core.Const.decoders
val make : ID.t -> ty -> t

Make a new uninterpreted function.

val uconst_of_id : +Uconst (sidekick-base.Sidekick_base.Uconst)

Module Sidekick_base.Uconst

Uninterpreted constants

type t = Types_.uconst = {
  1. uc_id : ID.t;
  2. uc_ty : ty;
}
val id : t -> ID.t
val ty : t -> ty
type Sidekick_core.Const.view +=
  1. | Uconst of t
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val const_decoders : Sidekick_core.Const.decoders
val make : ID.t -> ty -> t

Make a new uninterpreted function.

val uconst_of_id : Sidekick_core.Term.store -> ID.t -> ty -> @@ -13,4 +13,4 @@ string -> ty list -> ty -> - Sidekick_core.Term.t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
\ No newline at end of file + Sidekick_core.Term.t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
diff --git a/dev/sidekick-base/Sidekick_base/index.html b/dev/sidekick-base/Sidekick_base/index.html index f3250861..30be6915 100644 --- a/dev/sidekick-base/Sidekick_base/index.html +++ b/dev/sidekick-base/Sidekick_base/index.html @@ -1,7 +1,7 @@ -Sidekick_base (sidekick-base.Sidekick_base)

Module Sidekick_base

Sidekick base

This library is a starting point for writing concrete implementations of SMT solvers with Sidekick.

It provides a representation of terms, boolean formulas, linear arithmetic expressions, datatypes for the functors in Sidekick.

In addition, it has a notion of Statement. Statements are instructions for the SMT solver to do something, such as: define a new constant, declare a new constant, assert a formula as being true, set an option, check satisfiability of the set of statements added so far, etc. Logic formats such as SMT-LIB 2.6 are in fact based on a similar notion of statements, and a .smt2 files contains a list of statements.

module Types_ : sig ... end
module Term : sig ... end
module Const = Sidekick_core.Const
module Ty : sig ... end
module ID : sig ... end

Unique Identifiers

module Form : sig ... end

Formulas (boolean terms).

module Data_ty : sig ... end
module Cstor = Data_ty.Cstor
module Select = Data_ty.Select
module Statement : sig ... end

Statements.

module Solver : sig ... end
module Uconst : sig ... end

Uninterpreted constants

module Config : sig ... end

Configuration

module LRA_term : sig ... end
module Th_data : sig ... end

Theory of datatypes

module Th_bool : sig ... end

Reducing boolean formulas to clauses

module Th_lra : sig ... end

Theory of Linear Rational Arithmetic

module Th_ty_unin : sig ... end
val k_th_bool_config : [ `Dyn | `Static ] Config.Key.t
val th_bool : Config.t -> Solver.theory
val th_bool_dyn : Solver.theory
val th_bool_static : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
val th_ty_unin : Solver.theory
val const_decoders : +Sidekick_base (sidekick-base.Sidekick_base)

Module Sidekick_base

Sidekick base

This library is a starting point for writing concrete implementations of SMT solvers with Sidekick.

It provides a representation of terms, boolean formulas, linear arithmetic expressions, datatypes for the functors in Sidekick.

In addition, it has a notion of Statement. Statements are instructions for the SMT solver to do something, such as: define a new constant, declare a new constant, assert a formula as being true, set an option, check satisfiability of the set of statements added so far, etc. Logic formats such as SMT-LIB 2.6 are in fact based on a similar notion of statements, and a .smt2 files contains a list of statements.

module Types_ : sig ... end
module Term : sig ... end
module Const = Sidekick_core.Const
module Ty : sig ... end
module ID : sig ... end

Unique Identifiers

module Form : sig ... end

Formulas (boolean terms).

module Data_ty : sig ... end
module Cstor = Data_ty.Cstor
module Select = Data_ty.Select
module Statement : sig ... end

Statements.

module Solver : sig ... end
module Uconst : sig ... end

Uninterpreted constants

module Config : sig ... end

Configuration

module LRA_term : sig ... end
module Th_data : sig ... end

Theory of datatypes

module Th_bool : sig ... end

Reducing boolean formulas to clauses

module Th_lra : sig ... end

Theory of Linear Rational Arithmetic

module Th_ty_unin : sig ... end
val k_th_bool_config : [ `Dyn | `Static ] Config.Key.t
val th_bool : Config.t -> Solver.theory
val th_bool_dyn : Solver.theory
val th_bool_static : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
val th_ty_unin : Solver.theory
val const_decoders : (string * Sidekick_core.Const.Ops.t * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t -> Sidekick_core.Const.view Sidekick_util.Ser_decode.t)) - list

All constant decoders

\ No newline at end of file + list

All constant decoders

diff --git a/dev/sidekick-base/Sidekick_smtlib/.dummy b/dev/sidekick-base/Sidekick_smtlib/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick-base/Sidekick_smtlib/Check_cc/index.html b/dev/sidekick-base/Sidekick_smtlib/Check_cc/index.html index 3991590b..eefa87ee 100644 --- a/dev/sidekick-base/Sidekick_smtlib/Check_cc/index.html +++ b/dev/sidekick-base/Sidekick_smtlib/Check_cc/index.html @@ -1,2 +1,2 @@ -Check_cc (sidekick-base.Sidekick_smtlib.Check_cc)

Module Sidekick_smtlib.Check_cc

val theory : Solver.cdcl_theory

theory that check validity of EUF conflicts, on the fly

\ No newline at end of file +Check_cc (sidekick-base.Sidekick_smtlib.Check_cc)

Module Sidekick_smtlib.Check_cc

val theory : Solver.cdcl_theory

theory that check validity of EUF conflicts, on the fly

diff --git a/dev/sidekick-base/Sidekick_smtlib/Driver/index.html b/dev/sidekick-base/Sidekick_smtlib/Driver/index.html index 7cf1fec7..10a4e6ee 100644 --- a/dev/sidekick-base/Sidekick_smtlib/Driver/index.html +++ b/dev/sidekick-base/Sidekick_smtlib/Driver/index.html @@ -1,11 +1,11 @@ -Driver (sidekick-base.Sidekick_smtlib.Driver)

Module Sidekick_smtlib.Driver

Driver.

The driver is responsible for processing statements from a SMTLIB file, and interacting with the solver based on the statement (asserting formulas, calling "solve", etc.)

val th_bool_dyn : Sidekick_base.Solver.theory
val th_bool_static : Sidekick_base.Solver.theory
type 'a or_error = ('a, string) CCResult.t
type t

The SMTLIB driver

val create : - ?pp_cnf:bool -> - ?proof_file:string -> - ?pp_model:bool -> - ?check:bool -> - ?time:float -> - ?memory:float -> - ?progress:bool -> +Driver (sidekick-base.Sidekick_smtlib.Driver)

Module Sidekick_smtlib.Driver

Driver.

The driver is responsible for processing statements from a SMTLIB file, and interacting with the solver based on the statement (asserting formulas, calling "solve", etc.)

val th_bool_dyn : Sidekick_base.Solver.theory
val th_bool_static : Sidekick_base.Solver.theory
type 'a or_error = ('a, string) CCResult.t
type t

The SMTLIB driver

val create : + ?pp_cnf:bool -> + ?proof_file:string -> + ?pp_model:bool -> + ?check:bool -> + ?time:float -> + ?memory:float -> + ?progress:bool -> Asolver.t -> - t
val process_stmt : t -> Sidekick_base.Statement.t -> unit or_error
\ No newline at end of file + t
val process_stmt : t -> Sidekick_base.Statement.t -> unit or_error
diff --git a/dev/sidekick-base/Sidekick_smtlib/Model/index.html b/dev/sidekick-base/Sidekick_smtlib/Model/index.html index 1dd1b0f6..20954607 100644 --- a/dev/sidekick-base/Sidekick_smtlib/Model/index.html +++ b/dev/sidekick-base/Sidekick_smtlib/Model/index.html @@ -1,2 +1,2 @@ -Model (sidekick-base.Sidekick_smtlib.Model)

Module Sidekick_smtlib.Model

Models

A model can be produced when the solver is found to be in a satisfiable state after a call to solve.

type t
type fun_ = Sidekick_core.Term.t
module TL_map : CCMap.S with type key = value list
val empty : t
val is_empty : t -> bool
val add_fun_entry : fun_ -> value list -> value -> t -> t
val get_fun_entry : fun_ -> value list -> t -> value option
val get_fun_entries : fun_ -> t -> value TL_map.t option
val iter_fun_entries : t -> (fun_ * value TL_map.t) Iter.t
val eval : Sidekick_core.Term.t -> t -> value option
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Model (sidekick-base.Sidekick_smtlib.Model)

Module Sidekick_smtlib.Model

Models

A model can be produced when the solver is found to be in a satisfiable state after a call to solve.

type t
type fun_ = Sidekick_core.Term.t
module TL_map : CCMap.S with type key = value list
val empty : t
val is_empty : t -> bool
val add_fun_entry : fun_ -> value list -> value -> t -> t
val get_fun_entry : fun_ -> value list -> t -> value option
val get_fun_entries : fun_ -> t -> value TL_map.t option
val iter_fun_entries : t -> (fun_ * value TL_map.t) Iter.t
val eval : Sidekick_core.Term.t -> t -> value option
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_smtlib/Solver/index.html b/dev/sidekick-base/Sidekick_smtlib/Solver/index.html index d8b59a1d..92989135 100644 --- a/dev/sidekick-base/Sidekick_smtlib/Solver/index.html +++ b/dev/sidekick-base/Sidekick_smtlib/Solver/index.html @@ -1,2 +1,2 @@ -Solver (sidekick-base.Sidekick_smtlib.Solver)

Module Sidekick_smtlib.Solver

module Smt_solver = Sidekick_smt_solver
type t = Asolver.t
type cdcl_theory = Smt_solver.theory
\ No newline at end of file +Solver (sidekick-base.Sidekick_smtlib.Solver)

Module Sidekick_smtlib.Solver

module Smt_solver = Sidekick_smt_solver
type t = Asolver.t
type cdcl_theory = Smt_solver.theory
diff --git a/dev/sidekick-base/Sidekick_smtlib/index.html b/dev/sidekick-base/Sidekick_smtlib/index.html index 1700e51a..4dedd8c9 100644 --- a/dev/sidekick-base/Sidekick_smtlib/index.html +++ b/dev/sidekick-base/Sidekick_smtlib/index.html @@ -1,2 +1,2 @@ -Sidekick_smtlib (sidekick-base.Sidekick_smtlib)

Module Sidekick_smtlib

SMTLib-2.6 Driver

This library provides a parser, a type-checker, and a driver for processing SMTLib-2 problems.

type 'a or_error = ('a, string) CCResult.t
module Term = Sidekick_base.Term
module Driver : sig ... end

Driver.

module Solver : sig ... end
module Check_cc : sig ... end
module Model : sig ... end

Models

val parse : Term.store -> string -> Stmt.t list or_error
val parse_stdin : Term.store -> Stmt.t list or_error
\ No newline at end of file +Sidekick_smtlib (sidekick-base.Sidekick_smtlib)

Module Sidekick_smtlib

SMTLib-2.6 Driver

This library provides a parser, a type-checker, and a driver for processing SMTLib-2 problems.

type 'a or_error = ('a, string) CCResult.t
module Term = Sidekick_base.Term
module Driver : sig ... end

Driver.

module Solver : sig ... end
module Check_cc : sig ... end
module Model : sig ... end

Models

val parse : Term.store -> string -> Stmt.t list or_error
val parse_stdin : Term.store -> Stmt.t list or_error
diff --git a/dev/sidekick-base/index.html b/dev/sidekick-base/index.html index 4f6fdfab..9e25a301 100644 --- a/dev/sidekick-base/index.html +++ b/dev/sidekick-base/index.html @@ -1,2 +1,2 @@ -index (sidekick-base.index)

sidekick-base index

Library sidekick-base

The entry point of this library is the module: Sidekick_base.

Library sidekick-base.smtlib

The entry point of this library is the module: Sidekick_smtlib.

\ No newline at end of file +index (sidekick-base.index)

sidekick-base index

Library sidekick-base

The entry point of this library is the module: Sidekick_base.

Library sidekick-base.smtlib

The entry point of this library is the module: Sidekick_smtlib.

diff --git a/dev/sidekick-bin/Sidekick_bin_lib/.dummy b/dev/sidekick-bin/Sidekick_bin_lib/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_lexer/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_lexer/index.html index 7c881b0e..5744af7d 100644 --- a/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_lexer/index.html +++ b/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_lexer/index.html @@ -1,2 +1,2 @@ -Dimacs_lexer (sidekick-bin.Sidekick_bin_lib.Dimacs_lexer)

Module Sidekick_bin_lib.Dimacs_lexer

type token =
  1. | EOF
  2. | P
  3. | CNF
  4. | ZERO
  5. | LIT of int
val __ocaml_lex_tables : Stdlib.Lexing.lex_tables
val token : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> token
val comment : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> token
\ No newline at end of file +Dimacs_lexer (sidekick-bin.Sidekick_bin_lib.Dimacs_lexer)

Module Sidekick_bin_lib.Dimacs_lexer

type token =
  1. | EOF
  2. | P
  3. | CNF
  4. | ZERO
  5. | LIT of int
val __ocaml_lex_tables : Stdlib.Lexing.lex_tables
val token : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> token
val comment : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> token
diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_parser/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_parser/index.html index 527f6ab7..a7e482ef 100644 --- a/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_parser/index.html +++ b/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_parser/index.html @@ -1,2 +1,2 @@ -Dimacs_parser (sidekick-bin.Sidekick_bin_lib.Dimacs_parser)

Module Sidekick_bin_lib.Dimacs_parser

DIMACS parser

type t
val create : Stdlib.in_channel -> t
val parse_header : t -> int * int
val next_clause : t -> int list option
val iter : t -> int list Iter.t
\ No newline at end of file +Dimacs_parser (sidekick-bin.Sidekick_bin_lib.Dimacs_parser)

Module Sidekick_bin_lib.Dimacs_parser

DIMACS parser

type t
val create : Stdlib.in_channel -> t
val parse_header : t -> int * int
val next_clause : t -> int list option
val iter : t -> int list Iter.t
diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Drup_lexer/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Drup_lexer/index.html index 52192863..32645d93 100644 --- a/dev/sidekick-bin/Sidekick_bin_lib/Drup_lexer/index.html +++ b/dev/sidekick-bin/Sidekick_bin_lib/Drup_lexer/index.html @@ -1,2 +1,2 @@ -Drup_lexer (sidekick-bin.Sidekick_bin_lib.Drup_lexer)

Module Sidekick_bin_lib.Drup_lexer

type token =
  1. | EOF
  2. | ZERO
  3. | LIT of int
  4. | D
  5. | R
  6. | I
val __ocaml_lex_tables : Stdlib.Lexing.lex_tables
val token : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> token
val comment : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> token
\ No newline at end of file +Drup_lexer (sidekick-bin.Sidekick_bin_lib.Drup_lexer)

Module Sidekick_bin_lib.Drup_lexer

type token =
  1. | EOF
  2. | ZERO
  3. | LIT of int
  4. | D
  5. | R
  6. | I
val __ocaml_lex_tables : Stdlib.Lexing.lex_tables
val token : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> token
val comment : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> token
diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Drup_parser/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Drup_parser/index.html index f1dba79d..47312d8e 100644 --- a/dev/sidekick-bin/Sidekick_bin_lib/Drup_parser/index.html +++ b/dev/sidekick-bin/Sidekick_bin_lib/Drup_parser/index.html @@ -1,2 +1,2 @@ -Drup_parser (sidekick-bin.Sidekick_bin_lib.Drup_parser)

Module Sidekick_bin_lib.Drup_parser

DRUP parser

type t
type event =
  1. | Input of int list
  2. | Add of int list
  3. | Delete of int list
val create_chan : Stdlib.in_channel -> t
val create_string : string -> t
val next : t -> event option
val iter : t -> event Iter.t
\ No newline at end of file +Drup_parser (sidekick-bin.Sidekick_bin_lib.Drup_parser)

Module Sidekick_bin_lib.Drup_parser

DRUP parser

type t
type event =
  1. | Input of int list
  2. | Add of int list
  3. | Delete of int list
val create_chan : Stdlib.in_channel -> t
val create_string : string -> t
val next : t -> event option
val iter : t -> event Iter.t
diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Trace_setup/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Trace_setup/index.html new file mode 100644 index 00000000..8af0f865 --- /dev/null +++ b/dev/sidekick-bin/Sidekick_bin_lib/Trace_setup/index.html @@ -0,0 +1,2 @@ + +Trace_setup (sidekick-bin.Sidekick_bin_lib.Trace_setup)

Module Sidekick_bin_lib.Trace_setup

val with_trace : (unit -> 'a) -> 'a
diff --git a/dev/sidekick-bin/Sidekick_bin_lib/index.html b/dev/sidekick-bin/Sidekick_bin_lib/index.html index dbdd8120..c9ca5de8 100644 --- a/dev/sidekick-bin/Sidekick_bin_lib/index.html +++ b/dev/sidekick-bin/Sidekick_bin_lib/index.html @@ -1,2 +1,2 @@ -Sidekick_bin_lib (sidekick-bin.Sidekick_bin_lib)

Module Sidekick_bin_lib

Library for the Sidekick executables

module Dimacs_lexer : sig ... end
module Dimacs_parser : sig ... end
module Drup_lexer : sig ... end
module Drup_parser : sig ... end
\ No newline at end of file +Sidekick_bin_lib (sidekick-bin.Sidekick_bin_lib)

Module Sidekick_bin_lib

Library for the Sidekick executables

module Dimacs_lexer : sig ... end
module Dimacs_parser : sig ... end
module Drup_lexer : sig ... end
module Drup_parser : sig ... end
module Trace_setup : sig ... end
diff --git a/dev/sidekick-bin/index.html b/dev/sidekick-bin/index.html index 61387f16..b0a5b974 100644 --- a/dev/sidekick-bin/index.html +++ b/dev/sidekick-bin/index.html @@ -1,2 +1,2 @@ -index (sidekick-bin.index)

sidekick-bin index

Library sidekick-bin.lib

The entry point of this library is the module: Sidekick_bin_lib.

\ No newline at end of file +index (sidekick-bin.index)

sidekick-bin index

Library sidekick-bin.lib

The entry point of this library is the module: Sidekick_bin_lib.

diff --git a/dev/sidekick/Sidekick_abstract_solver/.dummy b/dev/sidekick/Sidekick_abstract_solver/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_abstract_solver/Asolver/class-type-t/index.html b/dev/sidekick/Sidekick_abstract_solver/Asolver/class-type-t/index.html index 49a2a3d1..ec635029 100644 --- a/dev/sidekick/Sidekick_abstract_solver/Asolver/class-type-t/index.html +++ b/dev/sidekick/Sidekick_abstract_solver/Asolver/class-type-t/index.html @@ -1,9 +1,9 @@ -t (sidekick.Sidekick_abstract_solver.Asolver.t)

Class type Asolver.t

method assert_term : Sidekick_core.Term.t -> unit

Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion.

This uses Proof_sat.sat_input_clause to justify the assertion.

method assert_clause : Sidekick_core.Lit.t array -> Proof.Pterm.delayed -> unit

add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.

method assert_clause_l : Sidekick_core.Lit.t list -> +t (sidekick.Sidekick_abstract_solver.Asolver.t)

Class type Asolver.t

method assert_term : Sidekick_core.Term.t -> unit

Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion.

This uses Proof_sat.sat_input_clause to justify the assertion.

method assert_clause : Sidekick_core.Lit.t array -> Proof.Pterm.delayed -> unit

add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.

method assert_clause_l : Sidekick_core.Lit.t list -> Proof.Pterm.delayed -> - unit

Add a clause to the solver, given as a list.

method add_ty : ty:Sidekick_core.Term.t -> unit

Add a new sort/atomic type.

method lit_of_term : ?sign:bool -> Sidekick_core.Term.t -> Sidekick_core.Lit.t

Convert a term into a simplified literal.

method solve : ?on_exit:(unit -> unit) list -> - ?on_progress:(unit -> unit) -> - ?should_stop:(int -> bool) -> - assumptions:Sidekick_core.Lit.t list -> + unit

Add a clause to the solver, given as a list.

method add_ty : ty:Sidekick_core.Term.t -> unit

Add a new sort/atomic type.

method lit_of_term : ?sign:bool -> Sidekick_core.Term.t -> Sidekick_core.Lit.t

Convert a term into a simplified literal.

method solve : ?on_exit:(unit -> unit) list -> + ?on_progress:(unit -> unit) -> + ?should_stop:(int -> bool) -> + assumptions:Sidekick_core.Lit.t list -> unit -> - Check_res.t

Checks the satisfiability of the clauses added so far to the solver.

  • parameter assumptions

    a set of atoms held to be true. The unsat core, if any, will be a subset of assumptions.

  • parameter on_progress

    called regularly during solving.

  • parameter should_stop

    a callback regularly called from within the solver. It is given a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

method last_res : Check_res.t option

Returns the result of the last call to solve, if the logic statee has not changed (mostly by asserting new clauses).

method proof_tracer : Proof.Tracer.t

TODO: remove, use Tracer instead

\ No newline at end of file + Check_res.t

Checks the satisfiability of the clauses added so far to the solver.

  • parameter assumptions

    a set of atoms held to be true. The unsat core, if any, will be a subset of assumptions.

  • parameter on_progress

    called regularly during solving.

  • parameter should_stop

    a callback regularly called from within the solver. It is given a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

method last_res : Check_res.t option

Returns the result of the last call to solve, if the logic statee has not changed (mostly by asserting new clauses).

method proof_tracer : Proof.Tracer.t

TODO: remove, use Tracer instead

diff --git a/dev/sidekick/Sidekick_abstract_solver/Asolver/index.html b/dev/sidekick/Sidekick_abstract_solver/Asolver/index.html index 1c6b57ad..268f2273 100644 --- a/dev/sidekick/Sidekick_abstract_solver/Asolver/index.html +++ b/dev/sidekick/Sidekick_abstract_solver/Asolver/index.html @@ -1,5 +1,5 @@ -Asolver (sidekick.Sidekick_abstract_solver.Asolver)

Module Sidekick_abstract_solver.Asolver

Abstract interface for a solver

module Unknown = Unknown
module Check_res = Check_res
module Proof = Sidekick_proof
class type t = object ... end
val assert_term : t -> Sidekick_core.Term.t -> unit
val assert_clause : +Asolver (sidekick.Sidekick_abstract_solver.Asolver)

Module Sidekick_abstract_solver.Asolver

Abstract interface for a solver

module Unknown = Unknown
module Check_res = Check_res
module Proof = Sidekick_proof
class type t = object ... end
val assert_term : t -> Sidekick_core.Term.t -> unit
val assert_clause : t -> Sidekick_core.Lit.t array -> Proof.Pterm.delayed -> @@ -7,15 +7,15 @@ t -> Sidekick_core.Lit.t list -> Proof.Pterm.delayed -> - unit
val add_ty : t -> ty:Sidekick_core.Term.t -> unit
val lit_of_term : + unit
val add_ty : t -> ty:Sidekick_core.Term.t -> unit
val lit_of_term : t -> - ?sign:bool -> + ?sign:bool -> Sidekick_core.Term.t -> Sidekick_core.Lit.t
val solve : t -> - ?on_exit:(unit -> unit) list -> - ?on_progress:(unit -> unit) -> - ?should_stop:(int -> bool) -> - assumptions:Sidekick_core.Lit.t list -> + ?on_exit:(unit -> unit) list -> + ?on_progress:(unit -> unit) -> + ?should_stop:(int -> bool) -> + assumptions:Sidekick_core.Lit.t list -> unit -> - Check_res.t
val last_res : t -> Check_res.t option
val proof : t -> Proof.Tracer.t
\ No newline at end of file + Check_res.t
val last_res : t -> Check_res.t option
val proof : t -> Proof.Tracer.t
diff --git a/dev/sidekick/Sidekick_abstract_solver/Check_res/index.html b/dev/sidekick/Sidekick_abstract_solver/Check_res/index.html index 549f5dda..ca1e4f38 100644 --- a/dev/sidekick/Sidekick_abstract_solver/Check_res/index.html +++ b/dev/sidekick/Sidekick_abstract_solver/Check_res/index.html @@ -1,2 +1,2 @@ -Check_res (sidekick.Sidekick_abstract_solver.Check_res)

Module Sidekick_abstract_solver.Check_res

Result of solving for the current set of clauses

type sat_result = {
  1. get_value : Sidekick_core.Term.t -> value option;
    (*

    Value for this term

    *)
  2. iter_classes : (Sidekick_core.Term.t Iter.t * value) Iter.t;
    (*

    All equivalence classes in the congruence closure

    *)
  3. eval_lit : Sidekick_core.Lit.t -> bool option;
    (*

    Evaluate literal

    *)
  4. iter_true_lits : Sidekick_core.Lit.t Iter.t;
    (*

    Iterate on literals that are true in the trail

    *)
}

Satisfiable

type unsat_result = {
  1. unsat_core : unit -> Sidekick_core.Lit.t Iter.t;
    (*

    Unsat core (subset of assumptions), or empty

    *)
  2. unsat_proof : unit -> Sidekick_proof.Step.id option;
    (*

    Proof step for the empty clause

    *)
}

Unsatisfiable

type t =
  1. | Sat of sat_result
  2. | Unsat of unsat_result
  3. | Unknown of Unknown.t
    (*

    Unknown, obtained after a timeout, memory limit, etc.

    *)

Result of calling "check"

val pp : Sidekick_core.Fmt.t -> t -> unit
\ No newline at end of file +Check_res (sidekick.Sidekick_abstract_solver.Check_res)

Module Sidekick_abstract_solver.Check_res

Result of solving for the current set of clauses

type sat_result = {
  1. get_value : Sidekick_core.Term.t -> value option;
    (*

    Value for this term

    *)
  2. iter_classes : (Sidekick_core.Term.t Iter.t * value) Iter.t;
    (*

    All equivalence classes in the congruence closure

    *)
  3. eval_lit : Sidekick_core.Lit.t -> bool option;
    (*

    Evaluate literal

    *)
  4. iter_true_lits : Sidekick_core.Lit.t Iter.t;
    (*

    Iterate on literals that are true in the trail

    *)
}

Satisfiable

type unsat_result = {
  1. unsat_core : unit -> Sidekick_core.Lit.t Iter.t;
    (*

    Unsat core (subset of assumptions), or empty

    *)
  2. unsat_proof : unit -> Sidekick_proof.Step.id option;
    (*

    Proof step for the empty clause

    *)
}

Unsatisfiable

type t =
  1. | Sat of sat_result
  2. | Unsat of unsat_result
  3. | Unknown of Unknown.t
    (*

    Unknown, obtained after a timeout, memory limit, etc.

    *)

Result of calling "check"

val pp : Sidekick_core.Fmt.t -> t -> unit
diff --git a/dev/sidekick/Sidekick_abstract_solver/Unknown/index.html b/dev/sidekick/Sidekick_abstract_solver/Unknown/index.html index 78d06c7e..8e3f00c0 100644 --- a/dev/sidekick/Sidekick_abstract_solver/Unknown/index.html +++ b/dev/sidekick/Sidekick_abstract_solver/Unknown/index.html @@ -1,2 +1,2 @@ -Unknown (sidekick.Sidekick_abstract_solver.Unknown)

Module Sidekick_abstract_solver.Unknown

type t =
  1. | U_timeout
  2. | U_max_depth
  3. | U_incomplete
  4. | U_asked_to_stop
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file +Unknown (sidekick.Sidekick_abstract_solver.Unknown)

Module Sidekick_abstract_solver.Unknown

type t =
  1. | U_timeout
  2. | U_max_depth
  3. | U_incomplete
  4. | U_asked_to_stop
val pp : t Sidekick_core.Fmt.printer
diff --git a/dev/sidekick/Sidekick_abstract_solver/class-type-t/index.html b/dev/sidekick/Sidekick_abstract_solver/class-type-t/index.html index 0ce834c9..093292f1 100644 --- a/dev/sidekick/Sidekick_abstract_solver/class-type-t/index.html +++ b/dev/sidekick/Sidekick_abstract_solver/class-type-t/index.html @@ -1,11 +1,11 @@ -t (sidekick.Sidekick_abstract_solver.t)

Class type Sidekick_abstract_solver.t

Main abstract solver type

method assert_term : Sidekick_core.Term.t -> unit

Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion.

This uses Proof_sat.sat_input_clause to justify the assertion.

method assert_clause : Sidekick_core.Lit.t array -> +t (sidekick.Sidekick_abstract_solver.t)

Class type Sidekick_abstract_solver.t

Main abstract solver type

method assert_term : Sidekick_core.Term.t -> unit

Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion.

This uses Proof_sat.sat_input_clause to justify the assertion.

method assert_clause : Sidekick_core.Lit.t array -> Asolver.Proof.Pterm.delayed -> unit

add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.

method assert_clause_l : Sidekick_core.Lit.t list -> Asolver.Proof.Pterm.delayed -> - unit

Add a clause to the solver, given as a list.

method add_ty : ty:Sidekick_core.Term.t -> unit

Add a new sort/atomic type.

method lit_of_term : ?sign:bool -> Sidekick_core.Term.t -> Sidekick_core.Lit.t

Convert a term into a simplified literal.

method solve : ?on_exit:(unit -> unit) list -> - ?on_progress:(unit -> unit) -> - ?should_stop:(int -> bool) -> - assumptions:Sidekick_core.Lit.t list -> + unit

Add a clause to the solver, given as a list.

method add_ty : ty:Sidekick_core.Term.t -> unit

Add a new sort/atomic type.

method lit_of_term : ?sign:bool -> Sidekick_core.Term.t -> Sidekick_core.Lit.t

Convert a term into a simplified literal.

method solve : ?on_exit:(unit -> unit) list -> + ?on_progress:(unit -> unit) -> + ?should_stop:(int -> bool) -> + assumptions:Sidekick_core.Lit.t list -> unit -> - Asolver.Check_res.t

Checks the satisfiability of the clauses added so far to the solver.

  • parameter assumptions

    a set of atoms held to be true. The unsat core, if any, will be a subset of assumptions.

  • parameter on_progress

    called regularly during solving.

  • parameter should_stop

    a callback regularly called from within the solver. It is given a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

method last_res : Asolver.Check_res.t option

Returns the result of the last call to solve, if the logic statee has not changed (mostly by asserting new clauses).

method proof_tracer : Asolver.Proof.Tracer.t

TODO: remove, use Tracer instead

\ No newline at end of file + Asolver.Check_res.t

Checks the satisfiability of the clauses added so far to the solver.

  • parameter assumptions

    a set of atoms held to be true. The unsat core, if any, will be a subset of assumptions.

  • parameter on_progress

    called regularly during solving.

  • parameter should_stop

    a callback regularly called from within the solver. It is given a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

method last_res : Asolver.Check_res.t option

Returns the result of the last call to solve, if the logic statee has not changed (mostly by asserting new clauses).

method proof_tracer : Asolver.Proof.Tracer.t

TODO: remove, use Tracer instead

diff --git a/dev/sidekick/Sidekick_abstract_solver/index.html b/dev/sidekick/Sidekick_abstract_solver/index.html index c831d306..c22b7d06 100644 --- a/dev/sidekick/Sidekick_abstract_solver/index.html +++ b/dev/sidekick/Sidekick_abstract_solver/index.html @@ -1,2 +1,2 @@ -Sidekick_abstract_solver (sidekick.Sidekick_abstract_solver)

Module Sidekick_abstract_solver

Abstract interface for a solver

module Unknown : sig ... end
module Check_res : sig ... end

Result of solving for the current set of clauses

module Asolver : sig ... end

Abstract interface for a solver

class type t = Asolver.t

Main abstract solver type

\ No newline at end of file +Sidekick_abstract_solver (sidekick.Sidekick_abstract_solver)

Module Sidekick_abstract_solver

Abstract interface for a solver

module Unknown : sig ... end
module Check_res : sig ... end

Result of solving for the current set of clauses

module Asolver : sig ... end

Abstract interface for a solver

class type t = Asolver.t

Main abstract solver type

diff --git a/dev/sidekick/Sidekick_arith/.dummy b/dev/sidekick/Sidekick_arith/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_arith/index.html b/dev/sidekick/Sidekick_arith/index.html index 91e1a7d6..62092457 100644 --- a/dev/sidekick/Sidekick_arith/index.html +++ b/dev/sidekick/Sidekick_arith/index.html @@ -1,2 +1,2 @@ -Sidekick_arith (sidekick.Sidekick_arith)

Module Sidekick_arith

module type NUM = sig ... end
module type INT = sig ... end
module type RATIONAL = sig ... end
module type INT_FULL = sig ... end
\ No newline at end of file +Sidekick_arith (sidekick.Sidekick_arith)

Module Sidekick_arith

module type NUM = sig ... end
module type INT = sig ... end
module type RATIONAL = sig ... end
module type INT_FULL = sig ... end
diff --git a/dev/sidekick/Sidekick_arith/module-type-INT/index.html b/dev/sidekick/Sidekick_arith/module-type-INT/index.html index 47054685..501f0f9e 100644 --- a/dev/sidekick/Sidekick_arith/module-type-INT/index.html +++ b/dev/sidekick/Sidekick_arith/module-type-INT/index.html @@ -1,2 +1,2 @@ -INT (sidekick.Sidekick_arith.INT)

Module type Sidekick_arith.INT

include NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file +INT (sidekick.Sidekick_arith.INT)

Module type Sidekick_arith.INT

include NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
diff --git a/dev/sidekick/Sidekick_arith/module-type-INT_FULL/index.html b/dev/sidekick/Sidekick_arith/module-type-INT_FULL/index.html index 10d85b96..5dfb1e75 100644 --- a/dev/sidekick/Sidekick_arith/module-type-INT_FULL/index.html +++ b/dev/sidekick/Sidekick_arith/module-type-INT_FULL/index.html @@ -1,2 +1,2 @@ -INT_FULL (sidekick.Sidekick_arith.INT_FULL)

Module type Sidekick_arith.INT_FULL

include INT
include NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
val sqrt : t -> t
val divexact : t -> t -> t
val (/) : t -> t -> t
val ediv : t -> t -> t

Euclidian division

val rem : t -> t -> t
val probab_prime : t -> bool
val pow : t -> int -> t
\ No newline at end of file +INT_FULL (sidekick.Sidekick_arith.INT_FULL)

Module type Sidekick_arith.INT_FULL

include INT
include NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
val sqrt : t -> t
val divexact : t -> t -> t
val (/) : t -> t -> t
val ediv : t -> t -> t

Euclidian division

val rem : t -> t -> t
val probab_prime : t -> bool
val pow : t -> int -> t
diff --git a/dev/sidekick/Sidekick_arith/module-type-NUM/index.html b/dev/sidekick/Sidekick_arith/module-type-NUM/index.html index 2770c780..590cfed6 100644 --- a/dev/sidekick/Sidekick_arith/module-type-NUM/index.html +++ b/dev/sidekick/Sidekick_arith/module-type-NUM/index.html @@ -1,2 +1,2 @@ -NUM (sidekick.Sidekick_arith.NUM)

Module type Sidekick_arith.NUM

type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
\ No newline at end of file +NUM (sidekick.Sidekick_arith.NUM)

Module type Sidekick_arith.NUM

type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
diff --git a/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html b/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html index a627c87d..811f788b 100644 --- a/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html +++ b/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html @@ -1,2 +1,2 @@ -RATIONAL (sidekick.Sidekick_arith.RATIONAL)

Module type Sidekick_arith.RATIONAL

include NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +RATIONAL (sidekick.Sidekick_arith.RATIONAL)

Module type Sidekick_arith.RATIONAL

include NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

diff --git a/dev/sidekick/Sidekick_bencode/.dummy b/dev/sidekick/Sidekick_bencode/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_bencode/Decode/index.html b/dev/sidekick/Sidekick_bencode/Decode/index.html index 273e217b..82b4dc90 100644 --- a/dev/sidekick/Sidekick_bencode/Decode/index.html +++ b/dev/sidekick/Sidekick_bencode/Decode/index.html @@ -1,2 +1,2 @@ -Decode (sidekick.Sidekick_bencode.Decode)

Module Sidekick_bencode.Decode

val of_string : ?idx:int -> string -> (int * t) option

Decode string, and also return how many bytes were consumed.

  • parameter idx

    initial index (default 0)

val of_string_exn : ?idx:int -> string -> int * t

Parse string.

  • raises Error.Error

    if the string is not valid bencode.

\ No newline at end of file +Decode (sidekick.Sidekick_bencode.Decode)

Module Sidekick_bencode.Decode

val of_string : ?idx:int -> string -> (int * t) option

Decode string, and also return how many bytes were consumed.

  • parameter idx

    initial index (default 0)

val of_string_exn : ?idx:int -> string -> int * t

Parse string.

  • raises Error.Error

    if the string is not valid bencode.

diff --git a/dev/sidekick/Sidekick_bencode/Encode/index.html b/dev/sidekick/Sidekick_bencode/Encode/index.html index 2639fd6a..ecd85c2d 100644 --- a/dev/sidekick/Sidekick_bencode/Encode/index.html +++ b/dev/sidekick/Sidekick_bencode/Encode/index.html @@ -1,2 +1,2 @@ -Encode (sidekick.Sidekick_bencode.Encode)

Module Sidekick_bencode.Encode

val to_buffer : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
\ No newline at end of file +Encode (sidekick.Sidekick_bencode.Encode)

Module Sidekick_bencode.Encode

val to_buffer : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
diff --git a/dev/sidekick/Sidekick_bencode/index.html b/dev/sidekick/Sidekick_bencode/index.html index 5b50a008..eb2018c1 100644 --- a/dev/sidekick/Sidekick_bencode/index.html +++ b/dev/sidekick/Sidekick_bencode/index.html @@ -1,2 +1,2 @@ -Sidekick_bencode (sidekick.Sidekick_bencode)

Module Sidekick_bencode

module Encode : sig ... end
module Decode : sig ... end
\ No newline at end of file +Sidekick_bencode (sidekick.Sidekick_bencode)

Module Sidekick_bencode

module Encode : sig ... end
module Decode : sig ... end
diff --git a/dev/sidekick/Sidekick_cc/.dummy b/dev/sidekick/Sidekick_cc/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_cc/CC/Handler_action/index.html b/dev/sidekick/Sidekick_cc/CC/Handler_action/index.html index a1efe3f7..4a59c37c 100644 --- a/dev/sidekick/Sidekick_cc/CC/Handler_action/index.html +++ b/dev/sidekick/Sidekick_cc/CC/Handler_action/index.html @@ -1,2 +1,2 @@ -Handler_action (sidekick.Sidekick_cc.CC.Handler_action)

Module CC.Handler_action

Handler Actions

Actions that can be scheduled by event handlers.

type t =
  1. | Act_merge of E_node.t * E_node.t * Expl.t
  2. | Act_propagate of Sidekick_core.Lit.t * propagation_reason
type conflict =
  1. | Conflict of Expl.t
type or_conflict = (t list, conflict) Stdlib.result

Actions or conflict scheduled by an event handler.

  • Ok acts is a list of merges and propagations
  • Error confl is a conflict to resolve.
\ No newline at end of file +Handler_action (sidekick.Sidekick_cc.CC.Handler_action)

Module CC.Handler_action

Handler Actions

Actions that can be scheduled by event handlers.

type t =
  1. | Act_merge of E_node.t * E_node.t * Expl.t
  2. | Act_propagate of Sidekick_core.Lit.t * propagation_reason
type conflict =
  1. | Conflict of Expl.t
type or_conflict = (t list, conflict) Stdlib.result

Actions or conflict scheduled by an event handler.

  • Ok acts is a list of merges and propagations
  • Error confl is a conflict to resolve.
diff --git a/dev/sidekick/Sidekick_cc/CC/Make/argument-1-_/index.html b/dev/sidekick/Sidekick_cc/CC/Make/argument-1-_/index.html index d60520e5..1b2a7029 100644 --- a/dev/sidekick/Sidekick_cc/CC/Make/argument-1-_/index.html +++ b/dev/sidekick/Sidekick_cc/CC/Make/argument-1-_/index.html @@ -1,2 +1,2 @@ -_ (sidekick.Sidekick_cc.CC.Make._)

Parameter Make._

val view_as_cc : view_as_cc

View the Term.t through the lens of the congruence closure

\ No newline at end of file +_ (sidekick.Sidekick_cc.CC.Make._)

Parameter Make._

val view_as_cc : view_as_cc

View the Term.t through the lens of the congruence closure

diff --git a/dev/sidekick/Sidekick_cc/CC/Make/index.html b/dev/sidekick/Sidekick_cc/CC/Make/index.html index d25655ad..9424f7ee 100644 --- a/dev/sidekick/Sidekick_cc/CC/Make/index.html +++ b/dev/sidekick/Sidekick_cc/CC/Make/index.html @@ -1,7 +1,7 @@ -Make (sidekick.Sidekick_cc.CC.Make)

Module CC.Make

Parameters

module _ : ARG

Signature

val create : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Small | `Big ] -> +Make (sidekick.Sidekick_cc.CC.Make)

Module CC.Make

Parameters

module _ : ARG

Signature

val create : + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Small | `Big ] -> Sidekick_core.Term.store -> Sidekick_proof.Tracer.t -> - t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

\ No newline at end of file + t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

diff --git a/dev/sidekick/Sidekick_cc/CC/Result_action/index.html b/dev/sidekick/Sidekick_cc/CC/Result_action/index.html index ba575089..a0b4f9a3 100644 --- a/dev/sidekick/Sidekick_cc/CC/Result_action/index.html +++ b/dev/sidekick/Sidekick_cc/CC/Result_action/index.html @@ -1,2 +1,2 @@ -Result_action (sidekick.Sidekick_cc.CC.Result_action)

Module CC.Result_action

Result Actions.

Actions returned by the congruence closure after calling check.

type t =
  1. | Act_propagate of {
    1. lit : Sidekick_core.Lit.t;
    2. reason : propagation_reason;
    }
    (*

    propagate (Lit.t, reason) declares that reason() => Lit.t is a tautology.

    • reason() should return a list of literals that are currently true, as well as a proof.
    • Lit.t should be a literal of interest (see S.set_as_lit).

    This function might never be called, a congruence closure has the right to not propagate and only trigger conflicts.

    *)
type conflict =
  1. | Conflict of Sidekick_core.Lit.t list * Sidekick_proof.Step.id
    (*

    raise_conflict (c,pr) declares that c is a tautology of the theory of congruence.

    • parameter pr

      the proof of c being a tautology

    *)
type or_conflict = (t list, conflict) Stdlib.result
\ No newline at end of file +Result_action (sidekick.Sidekick_cc.CC.Result_action)

Module CC.Result_action

Result Actions.

Actions returned by the congruence closure after calling check.

type t =
  1. | Act_propagate of {
    1. lit : Sidekick_core.Lit.t;
    2. reason : propagation_reason;
    }
    (*

    propagate (Lit.t, reason) declares that reason() => Lit.t is a tautology.

    • reason() should return a list of literals that are currently true, as well as a proof.
    • Lit.t should be a literal of interest (see S.set_as_lit).

    This function might never be called, a congruence closure has the right to not propagate and only trigger conflicts.

    *)
type conflict =
  1. | Conflict of Sidekick_core.Lit.t list * Sidekick_proof.Step.id
    (*

    raise_conflict (c,pr) declares that c is a tautology of the theory of congruence.

    • parameter pr

      the proof of c being a tautology

    *)
type or_conflict = (t list, conflict) Stdlib.result
diff --git a/dev/sidekick/Sidekick_cc/CC/index.html b/dev/sidekick/Sidekick_cc/CC/index.html index 6a011342..c3c6a4a9 100644 --- a/dev/sidekick/Sidekick_cc/CC/index.html +++ b/dev/sidekick/Sidekick_cc/CC/index.html @@ -1,5 +1,5 @@ -CC (sidekick.Sidekick_cc.CC)

Module Sidekick_cc.CC

Main congruence closure signature.

The congruence closure handles the theory QF_UF (uninterpreted function symbols). It is also responsible for theory combination, and provides a general framework for equality reasoning that other theories piggyback on.

For example, the theory of datatypes relies on the congruence closure to do most of the work, and "only" adds injectivity/disjointness/acyclicity lemmas when needed.

Similarly, a theory of arrays would hook into the congruence closure and assert (dis)equalities as needed.

type e_node = E_node.t

A node of the congruence closure

type repr = E_node.t

Node that is currently a representative.

type explanation = Expl.t
type bitfield

A field in the bitfield of this node. This should only be allocated when a theory is initialized.

Bitfields are accessed using preallocated keys. See allocate_bitfield.

All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.

type t

The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.

Accessors

val term_store : t -> Sidekick_core.Term.store
val proof_tracer : t -> Sidekick_proof.Tracer.t
val stat : t -> Sidekick_util.Stat.t
val find : t -> e_node -> repr

Current representative

val add_term : t -> Sidekick_core.Term.t -> e_node

Add the Term.t to the congruence closure, if not present already. Will be backtracked.

val mem_term : t -> Sidekick_core.Term.t -> bool

Returns true if the Term.t is explicitly present in the congruence closure

val allocate_bitfield : t -> descr:string -> bitfield

Allocate a new e_node field (see E_node.bitfield).

This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each class_ individually. This can be used to efficiently store some metadata on nodes (e.g. "is there a numeric value in the class" or "is there a constructor Term.t in the class").

There may be restrictions on how many distinct fields are allocated for a given congruence closure (e.g. at most Sys.int_size fields).

val get_bitfield : t -> bitfield -> E_node.t -> bool

Access the bit field of the given e_node

val set_bitfield : t -> bitfield -> bool -> E_node.t -> unit

Set the bitfield for the e_node. This will be backtracked. See E_node.bitfield.

type propagation_reason = +CC (sidekick.Sidekick_cc.CC)

Module Sidekick_cc.CC

Main congruence closure signature.

The congruence closure handles the theory QF_UF (uninterpreted function symbols). It is also responsible for theory combination, and provides a general framework for equality reasoning that other theories piggyback on.

For example, the theory of datatypes relies on the congruence closure to do most of the work, and "only" adds injectivity/disjointness/acyclicity lemmas when needed.

Similarly, a theory of arrays would hook into the congruence closure and assert (dis)equalities as needed.

type e_node = E_node.t

A node of the congruence closure

type repr = E_node.t

Node that is currently a representative.

type explanation = Expl.t
type bitfield

A field in the bitfield of this node. This should only be allocated when a theory is initialized.

Bitfields are accessed using preallocated keys. See allocate_bitfield.

All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.

type t

The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.

Accessors

val term_store : t -> Sidekick_core.Term.store
val proof_tracer : t -> Sidekick_proof.Tracer.t
val stat : t -> Sidekick_util.Stat.t
val find : t -> e_node -> repr

Current representative

val add_term : t -> Sidekick_core.Term.t -> e_node

Add the Term.t to the congruence closure, if not present already. Will be backtracked.

val mem_term : t -> Sidekick_core.Term.t -> bool

Returns true if the Term.t is explicitly present in the congruence closure

val allocate_bitfield : t -> descr:string -> bitfield

Allocate a new e_node field (see E_node.bitfield).

This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each class_ individually. This can be used to efficiently store some metadata on nodes (e.g. "is there a numeric value in the class" or "is there a constructor Term.t in the class").

There may be restrictions on how many distinct fields are allocated for a given congruence closure (e.g. at most Sys.int_size fields).

val get_bitfield : t -> bitfield -> E_node.t -> bool

Access the bit field of the given e_node

val set_bitfield : t -> bitfield -> bool -> E_node.t -> unit

Set the bitfield for the e_node. This will be backtracked. See E_node.bitfield.

type propagation_reason = unit -> Sidekick_core.Lit.t list * Sidekick_proof.Pterm.delayed
module Handler_action : sig ... end

Handler Actions

module Result_action : sig ... end

Result Actions.

Events

Events triggered by the congruence closure, to which other plugins can subscribe.

val on_pre_merge : t -> @@ -15,10 +15,10 @@ Sidekick_util.Event.t

ev_on_new_term n t is emitted whenever a new Term.t t is added to the congruence closure. Its E_node.t is n.

type ev_on_conflict = {
  1. cc : t;
  2. th : bool;
  3. c : Sidekick_core.Lit.t list;
}

Event emitted when a conflict occurs in the CC.

th is true if the explanation for this conflict involves at least one "theory" explanation; i.e. some of the equations participating in the conflict are purely syntactic theories like injectivity of constructors.

val on_conflict : t -> (ev_on_conflict, unit) Sidekick_util.Event.t

ev_on_conflict {th; c} is emitted when the congruence closure triggers a conflict by asserting the tautology c.

ev_on_propagate Lit.t reason is emitted whenever reason() => Lit.t is a propagated lemma. See CC_ACTIONS.propagate.

val on_is_subterm : + Sidekick_util.Event.t

ev_on_propagate Lit.t reason is emitted whenever reason() => Lit.t is a propagated lemma. See CC_ACTIONS.propagate.

ev_on_is_subterm n t is emitted when n is a subterm of another E_node.t for the first time. t is the Term.t corresponding to the E_node.t n. This can be useful for theory combination.

Misc

val n_true : t -> E_node.t

Node for true

val n_false : t -> E_node.t

Node for false

val n_bool : t -> bool -> E_node.t

Node for either true or false

val set_as_lit : t -> E_node.t -> Sidekick_core.Lit.t -> unit

map the given e_node to a literal.

val find_t : t -> Sidekick_core.Term.t -> repr

Current representative of the Term.t.

  • raises E_node.t_found

    if the Term.t is not already add-ed.

val add_iter : t -> Sidekick_core.Term.t Iter.t -> unit

Add a sequence of terms to the congruence closure

val all_classes : t -> repr Iter.t

All current classes. This is costly, only use if there is no other solution

val explain_eq : t -> E_node.t -> E_node.t -> Resolved_expl.t

Explain why the two nodes are equal. Fails if they are not, in an unspecified way.

val explain_expl : t -> Expl.t -> Resolved_expl.t

Transform explanation into an actionable conflict clause

val merge : t -> E_node.t -> E_node.t -> Expl.t -> unit

Merge these two nodes given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val merge_t : + Sidekick_util.Event.t

ev_on_is_subterm n t is emitted when n is a subterm of another E_node.t for the first time. t is the Term.t corresponding to the E_node.t n. This can be useful for theory combination.

Misc

val n_true : t -> E_node.t

Node for true

val n_false : t -> E_node.t

Node for false

val n_bool : t -> bool -> E_node.t

Node for either true or false

val set_as_lit : t -> E_node.t -> Sidekick_core.Lit.t -> unit

map the given e_node to a literal.

val find_t : t -> Sidekick_core.Term.t -> repr

Current representative of the Term.t.

  • raises E_node.t_found

    if the Term.t is not already add-ed.

val add_iter : t -> Sidekick_core.Term.t Iter.t -> unit

Add a sequence of terms to the congruence closure

val all_classes : t -> repr Iter.t

All current classes. This is costly, only use if there is no other solution

val explain_eq : t -> E_node.t -> E_node.t -> Resolved_expl.t

Explain why the two nodes are equal. Fails if they are not, in an unspecified way.

val explain_expl : t -> Expl.t -> Resolved_expl.t

Transform explanation into an actionable conflict clause

val merge : t -> E_node.t -> E_node.t -> Expl.t -> unit

Merge these two nodes given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

module type ARG = sig ... end

Arguments to a congruence closure's implementation

module type BUILD = sig ... end
module Make (_ : ARG) : BUILD
val create : (module ARG) -> - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Small | `Big ] -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Small | `Big ] -> Sidekick_core.Term.store -> Sidekick_proof.Tracer.t -> t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

val create_default : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Small | `Big ] -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Small | `Big ] -> Sidekick_core.Term.store -> Sidekick_proof.Tracer.t -> - t

Same as create but with the default CC view

\ No newline at end of file + t

Same as create but with the default CC view

diff --git a/dev/sidekick/Sidekick_cc/CC/module-type-ARG/index.html b/dev/sidekick/Sidekick_cc/CC/module-type-ARG/index.html index 71b76781..62ea3cbc 100644 --- a/dev/sidekick/Sidekick_cc/CC/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_cc/CC/module-type-ARG/index.html @@ -1,2 +1,2 @@ -ARG (sidekick.Sidekick_cc.CC.ARG)

Module type CC.ARG

Arguments to a congruence closure's implementation

val view_as_cc : view_as_cc

View the Term.t through the lens of the congruence closure

\ No newline at end of file +ARG (sidekick.Sidekick_cc.CC.ARG)

Module type CC.ARG

Arguments to a congruence closure's implementation

val view_as_cc : view_as_cc

View the Term.t through the lens of the congruence closure

diff --git a/dev/sidekick/Sidekick_cc/CC/module-type-BUILD/index.html b/dev/sidekick/Sidekick_cc/CC/module-type-BUILD/index.html index 71b0b331..51914a5f 100644 --- a/dev/sidekick/Sidekick_cc/CC/module-type-BUILD/index.html +++ b/dev/sidekick/Sidekick_cc/CC/module-type-BUILD/index.html @@ -1,7 +1,7 @@ -BUILD (sidekick.Sidekick_cc.CC.BUILD)

Module type CC.BUILD

val create : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Small | `Big ] -> +BUILD (sidekick.Sidekick_cc.CC.BUILD)

Module type CC.BUILD

val create : + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Small | `Big ] -> Sidekick_core.Term.store -> Sidekick_proof.Tracer.t -> - t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

\ No newline at end of file + t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

diff --git a/dev/sidekick/Sidekick_cc/E_node/Internal_/index.html b/dev/sidekick/Sidekick_cc/E_node/Internal_/index.html index d77a3864..b4e9f2ed 100644 --- a/dev/sidekick/Sidekick_cc/E_node/Internal_/index.html +++ b/dev/sidekick/Sidekick_cc/E_node/Internal_/index.html @@ -1,2 +1,2 @@ -Internal_ (sidekick.Sidekick_cc.E_node.Internal_)

Module E_node.Internal_

val iter_class_ : t -> t Iter.t
val make : Sidekick_core.Term.t -> t
\ No newline at end of file +Internal_ (sidekick.Sidekick_cc.E_node.Internal_)

Module E_node.Internal_

val iter_class_ : t -> t Iter.t
val make : Sidekick_core.Term.t -> t
diff --git a/dev/sidekick/Sidekick_cc/E_node/index.html b/dev/sidekick/Sidekick_cc/E_node/index.html index 50cf97d1..eea6f705 100644 --- a/dev/sidekick/Sidekick_cc/E_node/index.html +++ b/dev/sidekick/Sidekick_cc/E_node/index.html @@ -1,2 +1,2 @@ -E_node (sidekick.Sidekick_cc.E_node)

Module Sidekick_cc.E_node

E-node.

An e-node is a node in the congruence closure that is contained in some equivalence classe). An equivalence class is a set of terms that are currently equal in the partial model built by the solver. The class is represented by a collection of nodes, one of which is distinguished and is called the "representative".

All information pertaining to the whole equivalence class is stored in its representative's E_node.t.

When two classes become equal (are "merged"), one of the two representatives is picked as the representative of the new class. The new class contains the union of the two old classes' nodes.

We also allow theories to store additional information in the representative. This information can be used when two classes are merged, to detect conflicts and solve equations à la Shostak.

type t

An E-node.

A value of type t points to a particular Term.t, but see find to get the representative of the class.

include Sidekick_sigs.PRINT with type t := t
val term : t -> Sidekick_core.Term.t

Term contained in this equivalence class. If is_root n, then Term.t n is the class' representative Term.t.

val equal : t -> t -> bool

Are two classes physically equal? To check for logical equality, use CC.E_node.equal (CC.find cc n1) (CC.find cc n2) which checks for equality of representatives.

val hash : t -> int

An opaque hash of this E_node.t.

val is_root : t -> bool

Is the E_node.t a root (ie the representative of its class)? See find to get the root.

val iter_class : t -> t Iter.t

Traverse the congruence class. Precondition: is_root n (see find below)

val iter_parents : t -> t Iter.t

Traverse the parents of the class. Precondition: is_root n (see find below)

val as_lit : t -> Sidekick_core.Lit.t option
val swap_next : t -> t -> unit

Swap the next pointer of each node. If their classes were disjoint, they are now unioned.

module Internal_ : sig ... end
\ No newline at end of file +E_node (sidekick.Sidekick_cc.E_node)

Module Sidekick_cc.E_node

E-node.

An e-node is a node in the congruence closure that is contained in some equivalence classe). An equivalence class is a set of terms that are currently equal in the partial model built by the solver. The class is represented by a collection of nodes, one of which is distinguished and is called the "representative".

All information pertaining to the whole equivalence class is stored in its representative's E_node.t.

When two classes become equal (are "merged"), one of the two representatives is picked as the representative of the new class. The new class contains the union of the two old classes' nodes.

We also allow theories to store additional information in the representative. This information can be used when two classes are merged, to detect conflicts and solve equations à la Shostak.

type t

An E-node.

A value of type t points to a particular Term.t, but see find to get the representative of the class.

include Sidekick_sigs.PRINT with type t := t
val term : t -> Sidekick_core.Term.t

Term contained in this equivalence class. If is_root n, then Term.t n is the class' representative Term.t.

val equal : t -> t -> bool

Are two classes physically equal? To check for logical equality, use CC.E_node.equal (CC.find cc n1) (CC.find cc n2) which checks for equality of representatives.

val hash : t -> int

An opaque hash of this E_node.t.

val is_root : t -> bool

Is the E_node.t a root (ie the representative of its class)? See find to get the root.

val iter_class : t -> t Iter.t

Traverse the congruence class. Precondition: is_root n (see find below)

val iter_parents : t -> t Iter.t

Traverse the parents of the class. Precondition: is_root n (see find below)

val as_lit : t -> Sidekick_core.Lit.t option
val swap_next : t -> t -> unit

Swap the next pointer of each node. If their classes were disjoint, they are now unioned.

module Internal_ : sig ... end
diff --git a/dev/sidekick/Sidekick_cc/Expl/index.html b/dev/sidekick/Sidekick_cc/Expl/index.html index a8531803..bce7be4d 100644 --- a/dev/sidekick/Sidekick_cc/Expl/index.html +++ b/dev/sidekick/Sidekick_cc/Expl/index.html @@ -1,7 +1,7 @@ -Expl (sidekick.Sidekick_cc.Expl)

Module Sidekick_cc.Expl

Explanations

Explanations are specialized proofs, created by the congruence closure when asked to justify why two terms are equal.

type t
include Sidekick_sigs.PRINT with type t := t
val mk_merge : E_node.t -> E_node.t -> t

Explanation: the nodes were explicitly merged

Explanation: the terms were explicitly merged

val mk_lit : Sidekick_core.Lit.t -> t

Explanation: we merged t and u because of literal t=u, or we merged t and true because of literal t, or t and false because of literal ¬t

val mk_list : t list -> t

Conjunction of explanations

val mk_congruence : E_node.t -> E_node.t -> t
val mk_theory : +Expl (sidekick.Sidekick_cc.Expl)

Module Sidekick_cc.Expl

Explanations

Explanations are specialized proofs, created by the congruence closure when asked to justify why two terms are equal.

type t
include Sidekick_sigs.PRINT with type t := t
val mk_merge : E_node.t -> E_node.t -> t

Explanation: the nodes were explicitly merged

Explanation: the terms were explicitly merged

val mk_lit : Sidekick_core.Lit.t -> t

Explanation: we merged t and u because of literal t=u, or we merged t and true because of literal t, or t and false because of literal ¬t

val mk_list : t list -> t

Conjunction of explanations

val mk_congruence : E_node.t -> E_node.t -> t

mk_theory t u expl_sets pr builds a theory explanation for why |- t=u. It depends on sub-explanations expl_sets which are tuples (t_i, u_i, expls_i) where expls_i are explanations that justify t_i = u_i in the current congruence closure.

The proof pr is the theory lemma, of the form (t_i = u_i)_i |- t=u . It is resolved against each expls_i |- t_i=u_i obtained from expl_sets, on pivot t_i=u_i, to obtain a proof of Gamma |- t=u where Gamma is a subset of the literals asserted into the congruence closure.

For example for the lemma a=b deduced by injectivity from Some a=Some b in the theory of datatypes, the arguments would be a, b, [Some a, Some b, mk_merge_t (Some a)(Some b)], pr where pr is the injectivity lemma Some a=Some b |- a=b.

\ No newline at end of file + t

mk_theory t u expl_sets pr builds a theory explanation for why |- t=u. It depends on sub-explanations expl_sets which are tuples (t_i, u_i, expls_i) where expls_i are explanations that justify t_i = u_i in the current congruence closure.

The proof pr is the theory lemma, of the form (t_i = u_i)_i |- t=u . It is resolved against each expls_i |- t_i=u_i obtained from expl_sets, on pivot t_i=u_i, to obtain a proof of Gamma |- t=u where Gamma is a subset of the literals asserted into the congruence closure.

For example for the lemma a=b deduced by injectivity from Some a=Some b in the theory of datatypes, the arguments would be a, b, [Some a, Some b, mk_merge_t (Some a)(Some b)], pr where pr is the injectivity lemma Some a=Some b |- a=b.

diff --git a/dev/sidekick/Sidekick_cc/Plugin/Make/argument-1-M/index.html b/dev/sidekick/Sidekick_cc/Plugin/Make/argument-1-M/index.html index 61e4d0ce..bf321409 100644 --- a/dev/sidekick/Sidekick_cc/Plugin/Make/argument-1-M/index.html +++ b/dev/sidekick/Sidekick_cc/Plugin/Make/argument-1-M/index.html @@ -1,5 +1,5 @@ -M (sidekick.Sidekick_cc.Plugin.Make.M)

Parameter Make.M

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : +M (sidekick.Sidekick_cc.Plugin.Make.M)

Parameter Make.M

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : CC.t -> state -> E_node.t -> @@ -12,4 +12,4 @@ E_node.t -> t -> Expl.t -> - (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

\ No newline at end of file + (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

diff --git a/dev/sidekick/Sidekick_cc/Plugin/Make/index.html b/dev/sidekick/Sidekick_cc/Plugin/Make/index.html index 8fe5ad2d..7c264155 100644 --- a/dev/sidekick/Sidekick_cc/Plugin/Make/index.html +++ b/dev/sidekick/Sidekick_cc/Plugin/Make/index.html @@ -1,2 +1,2 @@ -Make (sidekick.Sidekick_cc.Plugin.Make)

Module Plugin.Make

Create a plugin builder from the given per-class monoid

Parameters

module M : sig ... end

Signature

module M = M
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t

Create a new monoid state

val mem : t -> E_node.t -> bool

Does the CC.E_node.t have a monoid value?

val get : t -> E_node.t -> M.t option

Get monoid value for this CC.E_node.t, if any

val iter_all : t -> (CC.repr * M.t) Iter.t
include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int

Number of levels

val push_level : t -> unit

Push a backtracking point

val pop_levels : t -> int -> unit

pop_levels st n removes n levels

include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Make (sidekick.Sidekick_cc.Plugin.Make)

Module Plugin.Make

Create a plugin builder from the given per-class monoid

Parameters

module M : sig ... end

Signature

module M = M
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t

Create a new monoid state

val mem : t -> E_node.t -> bool

Does the CC.E_node.t have a monoid value?

val get : t -> E_node.t -> M.t option

Get monoid value for this CC.E_node.t, if any

val iter_all : t -> (CC.repr * M.t) Iter.t
include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int

Number of levels

val push_level : t -> unit

Push a backtracking point

val pop_levels : t -> int -> unit

pop_levels st n removes n levels

include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick/Sidekick_cc/Plugin/Make/module-type-DYN_PL_FOR_M/index.html b/dev/sidekick/Sidekick_cc/Plugin/Make/module-type-DYN_PL_FOR_M/index.html index 9ea1dbf1..a797cd8c 100644 --- a/dev/sidekick/Sidekick_cc/Plugin/Make/module-type-DYN_PL_FOR_M/index.html +++ b/dev/sidekick/Sidekick_cc/Plugin/Make/module-type-DYN_PL_FOR_M/index.html @@ -1,2 +1,2 @@ -DYN_PL_FOR_M (sidekick.Sidekick_cc.Plugin.Make.DYN_PL_FOR_M)

Module type Make.DYN_PL_FOR_M

module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool

Does the CC E_node.t have a monoid value?

val get : E_node.t -> M.t option

Get monoid value for this CC E_node.t, if any

val iter_all : (CC.repr * M.t) Iter.t
\ No newline at end of file +DYN_PL_FOR_M (sidekick.Sidekick_cc.Plugin.Make.DYN_PL_FOR_M)

Module type Make.DYN_PL_FOR_M

module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool

Does the CC E_node.t have a monoid value?

val get : E_node.t -> M.t option

Get monoid value for this CC E_node.t, if any

val iter_all : (CC.repr * M.t) Iter.t
diff --git a/dev/sidekick/Sidekick_cc/Plugin/index.html b/dev/sidekick/Sidekick_cc/Plugin/index.html index 4c930dd4..d95932ee 100644 --- a/dev/sidekick/Sidekick_cc/Plugin/index.html +++ b/dev/sidekick/Sidekick_cc/Plugin/index.html @@ -1,2 +1,2 @@ -Plugin (sidekick.Sidekick_cc.Plugin)

Module Sidekick_cc.Plugin

Congruence Closure Plugin

module type EXTENDED_PLUGIN_BUILDER = sig ... end
module Make (M : sig ... end) : EXTENDED_PLUGIN_BUILDER with module M = M

Create a plugin builder from the given per-class monoid

\ No newline at end of file +Plugin (sidekick.Sidekick_cc.Plugin)

Module Sidekick_cc.Plugin

Congruence Closure Plugin

module type EXTENDED_PLUGIN_BUILDER = sig ... end
module Make (M : sig ... end) : EXTENDED_PLUGIN_BUILDER with module M = M

Create a plugin builder from the given per-class monoid

diff --git a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/M/index.html b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/M/index.html index d6e6d020..944b5844 100644 --- a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/M/index.html +++ b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/M/index.html @@ -1,5 +1,5 @@ -M (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER.M)

Module EXTENDED_PLUGIN_BUILDER.M

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : +M (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER.M)

Module EXTENDED_PLUGIN_BUILDER.M

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : CC.t -> state -> E_node.t -> @@ -12,4 +12,4 @@ E_node.t -> t -> Expl.t -> - (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

\ No newline at end of file + (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

diff --git a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/index.html b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/index.html index 95d28273..e16d81fe 100644 --- a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/index.html +++ b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/index.html @@ -1,2 +1,2 @@ -EXTENDED_PLUGIN_BUILDER (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER)

Module type Plugin.EXTENDED_PLUGIN_BUILDER

module M : sig ... end
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t

Create a new monoid state

val mem : t -> E_node.t -> bool

Does the CC.E_node.t have a monoid value?

val get : t -> E_node.t -> M.t option

Get monoid value for this CC.E_node.t, if any

val iter_all : t -> (CC.repr * M.t) Iter.t
include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int

Number of levels

val push_level : t -> unit

Push a backtracking point

val pop_levels : t -> int -> unit

pop_levels st n removes n levels

include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +EXTENDED_PLUGIN_BUILDER (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER)

Module type Plugin.EXTENDED_PLUGIN_BUILDER

module M : sig ... end
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t

Create a new monoid state

val mem : t -> E_node.t -> bool

Does the CC.E_node.t have a monoid value?

val get : t -> E_node.t -> M.t option

Get monoid value for this CC.E_node.t, if any

val iter_all : t -> (CC.repr * M.t) Iter.t
include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int

Number of levels

val push_level : t -> unit

Push a backtracking point

val pop_levels : t -> int -> unit

pop_levels st n removes n levels

include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html index e5c2ea7b..a77aedcb 100644 --- a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html +++ b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html @@ -1,2 +1,2 @@ -DYN_PL_FOR_M (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER.DYN_PL_FOR_M)

Module type EXTENDED_PLUGIN_BUILDER.DYN_PL_FOR_M

module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool

Does the CC E_node.t have a monoid value?

val get : E_node.t -> M.t option

Get monoid value for this CC E_node.t, if any

val iter_all : (CC.repr * M.t) Iter.t
\ No newline at end of file +DYN_PL_FOR_M (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER.DYN_PL_FOR_M)

Module type EXTENDED_PLUGIN_BUILDER.DYN_PL_FOR_M

module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool

Does the CC E_node.t have a monoid value?

val get : E_node.t -> M.t option

Get monoid value for this CC E_node.t, if any

val iter_all : (CC.repr * M.t) Iter.t
diff --git a/dev/sidekick/Sidekick_cc/Resolved_expl/index.html b/dev/sidekick/Sidekick_cc/Resolved_expl/index.html index 96eabaa8..fc403590 100644 --- a/dev/sidekick/Sidekick_cc/Resolved_expl/index.html +++ b/dev/sidekick/Sidekick_cc/Resolved_expl/index.html @@ -1,2 +1,2 @@ -Resolved_expl (sidekick.Sidekick_cc.Resolved_expl)

Module Sidekick_cc.Resolved_expl

Resolved explanations.

The congruence closure keeps explanations for why terms are in the same class. However these are represented in a compact, cheap form. To use these explanations we need to resolve them into a resolved explanation, typically a list of literals that are true in the current trail and are responsible for merges.

However, we can also have merged classes because they have the same value in the current model.

include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Resolved_expl (sidekick.Sidekick_cc.Resolved_expl)

Module Sidekick_cc.Resolved_expl

Resolved explanations.

The congruence closure keeps explanations for why terms are in the same class. However these are represented in a compact, cheap form. To use these explanations we need to resolve them into a resolved explanation, typically a list of literals that are true in the current trail and are responsible for merges.

However, we can also have merged classes because they have the same value in the current model.

include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick/Sidekick_cc/Signature/index.html b/dev/sidekick/Sidekick_cc/Signature/index.html index 59e8e2e4..5bd77f45 100644 --- a/dev/sidekick/Sidekick_cc/Signature/index.html +++ b/dev/sidekick/Sidekick_cc/Signature/index.html @@ -1,9 +1,9 @@ -Signature (sidekick.Sidekick_cc.Signature)

Module Sidekick_cc.Signature

A signature is a shallow term shape where immediate subterms are representative

type t = +Signature (sidekick.Sidekick_cc.Signature)

Module Sidekick_cc.Signature

A signature is a shallow term shape where immediate subterms are representative

type t = (Sidekick_core.Const.t, Sidekick_cc__.Types_.e_node, Sidekick_cc__.Types_.e_node list) Sidekick_core.CC_view.t
val equal : t -> t -> bool
val hash : t -> int
val pp : Sidekick_cc__.Types_.Fmt.t -> (Sidekick_core.Const.t, E_node.t, E_node.t list) Sidekick_core.CC_view.t -> - unit
\ No newline at end of file + unit
diff --git a/dev/sidekick/Sidekick_cc/index.html b/dev/sidekick/Sidekick_cc/index.html index 02b6231d..02a497c3 100644 --- a/dev/sidekick/Sidekick_cc/index.html +++ b/dev/sidekick/Sidekick_cc/index.html @@ -1,7 +1,7 @@ -Sidekick_cc (sidekick.Sidekick_cc)

Module Sidekick_cc

Congruence Closure Implementation

module type DYN_MONOID_PLUGIN = sig ... end
module type MONOID_PLUGIN_ARG = sig ... end
module type MONOID_PLUGIN_BUILDER = sig ... end
module View = Sidekick_core.CC_view
module E_node : sig ... end

E-node.

module Expl : sig ... end

Explanations

module Signature : sig ... end

A signature is a shallow term shape where immediate subterms are representative

module Resolved_expl : sig ... end

Resolved explanations.

module Plugin : sig ... end

Congruence Closure Plugin

module CC : sig ... end

Main congruence closure signature.

include module type of struct include CC end
type e_node = E_node.t

A node of the congruence closure

type repr = E_node.t

Node that is currently a representative.

type explanation = Expl.t
type bitfield

A field in the bitfield of this node. This should only be allocated when a theory is initialized.

Bitfields are accessed using preallocated keys. See allocate_bitfield.

All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.

type t = CC.t

The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.

Accessors

val term_store : t -> Sidekick_core.Term.store
val proof_tracer : t -> Sidekick_proof.Tracer.t
val stat : t -> Sidekick_util.Stat.t
val find : t -> e_node -> repr

Current representative

val add_term : t -> Sidekick_core.Term.t -> e_node

Add the Term.t to the congruence closure, if not present already. Will be backtracked.

val mem_term : t -> Sidekick_core.Term.t -> bool

Returns true if the Term.t is explicitly present in the congruence closure

val allocate_bitfield : t -> descr:string -> bitfield

Allocate a new e_node field (see E_node.bitfield).

This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each class_ individually. This can be used to efficiently store some metadata on nodes (e.g. "is there a numeric value in the class" or "is there a constructor Term.t in the class").

There may be restrictions on how many distinct fields are allocated for a given congruence closure (e.g. at most Sys.int_size fields).

val get_bitfield : t -> bitfield -> E_node.t -> bool

Access the bit field of the given e_node

val set_bitfield : t -> bitfield -> bool -> E_node.t -> unit

Set the bitfield for the e_node. This will be backtracked. See E_node.bitfield.

type propagation_reason = +Sidekick_cc (sidekick.Sidekick_cc)

Module Sidekick_cc

Congruence Closure Implementation

module type DYN_MONOID_PLUGIN = sig ... end
module type MONOID_PLUGIN_ARG = sig ... end
module type MONOID_PLUGIN_BUILDER = sig ... end
module View = Sidekick_core.CC_view
module E_node : sig ... end

E-node.

module Expl : sig ... end

Explanations

module Signature : sig ... end

A signature is a shallow term shape where immediate subterms are representative

module Resolved_expl : sig ... end

Resolved explanations.

module Plugin : sig ... end

Congruence Closure Plugin

module CC : sig ... end

Main congruence closure signature.

include module type of struct include CC end
type e_node = E_node.t

A node of the congruence closure

type repr = E_node.t

Node that is currently a representative.

type explanation = Expl.t
type bitfield

A field in the bitfield of this node. This should only be allocated when a theory is initialized.

Bitfields are accessed using preallocated keys. See allocate_bitfield.

All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.

type t = CC.t

The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.

Accessors

val term_store : t -> Sidekick_core.Term.store
val proof_tracer : t -> Sidekick_proof.Tracer.t
val stat : t -> Sidekick_util.Stat.t
val find : t -> e_node -> repr

Current representative

val add_term : t -> Sidekick_core.Term.t -> e_node

Add the Term.t to the congruence closure, if not present already. Will be backtracked.

val mem_term : t -> Sidekick_core.Term.t -> bool

Returns true if the Term.t is explicitly present in the congruence closure

val allocate_bitfield : t -> descr:string -> bitfield

Allocate a new e_node field (see E_node.bitfield).

This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each class_ individually. This can be used to efficiently store some metadata on nodes (e.g. "is there a numeric value in the class" or "is there a constructor Term.t in the class").

There may be restrictions on how many distinct fields are allocated for a given congruence closure (e.g. at most Sys.int_size fields).

val get_bitfield : t -> bitfield -> E_node.t -> bool

Access the bit field of the given e_node

val set_bitfield : t -> bitfield -> bool -> E_node.t -> unit

Set the bitfield for the e_node. This will be backtracked. See E_node.bitfield.

type propagation_reason = unit -> - Sidekick_core.Lit.t list * Sidekick_proof.Pterm.delayed
module Handler_action = CC.Handler_action

Handler Actions

module Result_action = CC.Result_action

Result Actions.

Events

Events triggered by the congruence closure, to which other plugins can subscribe.

module Handler_action = CC.Handler_action

Handler Actions

module Result_action = CC.Result_action

Result Actions.

Events

Events triggered by the congruence closure, to which other plugins can subscribe.

Events emitted by the congruence closure when something changes.

Ev_on_pre_merge acts n1 n2 expl is emitted right before n1 and n2 are merged with explanation expl.

val on_pre_merge2 : @@ -15,15 +15,15 @@ Sidekick_util.Event.t

ev_on_new_term n t is emitted whenever a new Term.t t is added to the congruence closure. Its E_node.t is n.

type ev_on_conflict = CC.ev_on_conflict = {
  1. cc : t;
  2. th : bool;
  3. c : Sidekick_core.Lit.t list;
}

Event emitted when a conflict occurs in the CC.

th is true if the explanation for this conflict involves at least one "theory" explanation; i.e. some of the equations participating in the conflict are purely syntactic theories like injectivity of constructors.

val on_conflict : t -> (ev_on_conflict, unit) Sidekick_util.Event.t

ev_on_conflict {th; c} is emitted when the congruence closure triggers a conflict by asserting the tautology c.

ev_on_propagate Lit.t reason is emitted whenever reason() => Lit.t is a propagated lemma. See CC_ACTIONS.propagate.

val on_is_subterm : + Sidekick_util.Event.t

ev_on_propagate Lit.t reason is emitted whenever reason() => Lit.t is a propagated lemma. See CC_ACTIONS.propagate.

ev_on_is_subterm n t is emitted when n is a subterm of another E_node.t for the first time. t is the Term.t corresponding to the E_node.t n. This can be useful for theory combination.

Misc

val n_true : t -> E_node.t

Node for true

val n_false : t -> E_node.t

Node for false

val n_bool : t -> bool -> E_node.t

Node for either true or false

val set_as_lit : t -> E_node.t -> Sidekick_core.Lit.t -> unit

map the given e_node to a literal.

val find_t : t -> Sidekick_core.Term.t -> repr

Current representative of the Term.t.

  • raises E_node.t_found

    if the Term.t is not already add-ed.

val add_iter : t -> Sidekick_core.Term.t Iter.t -> unit

Add a sequence of terms to the congruence closure

val all_classes : t -> repr Iter.t

All current classes. This is costly, only use if there is no other solution

val explain_eq : t -> E_node.t -> E_node.t -> Resolved_expl.t

Explain why the two nodes are equal. Fails if they are not, in an unspecified way.

val explain_expl : t -> Expl.t -> Resolved_expl.t

Transform explanation into an actionable conflict clause

val merge : t -> E_node.t -> E_node.t -> Expl.t -> unit

Merge these two nodes given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val merge_t : + Sidekick_util.Event.t

ev_on_is_subterm n t is emitted when n is a subterm of another E_node.t for the first time. t is the Term.t corresponding to the E_node.t n. This can be useful for theory combination.

Misc

val n_true : t -> E_node.t

Node for true

val n_false : t -> E_node.t

Node for false

val n_bool : t -> bool -> E_node.t

Node for either true or false

val set_as_lit : t -> E_node.t -> Sidekick_core.Lit.t -> unit

map the given e_node to a literal.

val find_t : t -> Sidekick_core.Term.t -> repr

Current representative of the Term.t.

  • raises E_node.t_found

    if the Term.t is not already add-ed.

val add_iter : t -> Sidekick_core.Term.t Iter.t -> unit

Add a sequence of terms to the congruence closure

val all_classes : t -> repr Iter.t

All current classes. This is costly, only use if there is no other solution

val explain_eq : t -> E_node.t -> E_node.t -> Resolved_expl.t

Explain why the two nodes are equal. Fails if they are not, in an unspecified way.

val explain_expl : t -> Expl.t -> Resolved_expl.t

Transform explanation into an actionable conflict clause

val merge : t -> E_node.t -> E_node.t -> Expl.t -> unit

Merge these two nodes given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val merge_t : t -> Sidekick_core.Term.t -> Sidekick_core.Term.t -> Expl.t -> - unit

Shortcut for adding + merging

Main API

val assert_eq : + unit

Shortcut for adding + merging

Main API

module type ARG = CC.ARG

Arguments to a congruence closure's implementation

module type BUILD = CC.BUILD
module Make = CC.Make
val create : (module ARG) -> - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Small | `Big ] -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Small | `Big ] -> Sidekick_core.Term.store -> Sidekick_proof.Tracer.t -> t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

val create_default : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Small | `Big ] -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Small | `Big ] -> Sidekick_core.Term.store -> Sidekick_proof.Tracer.t -> - t

Same as create but with the default CC view

\ No newline at end of file + t

Same as create but with the default CC view

diff --git a/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/M/index.html b/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/M/index.html index 19005ae7..81881d35 100644 --- a/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/M/index.html +++ b/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/M/index.html @@ -1,5 +1,5 @@ -M (sidekick.Sidekick_cc.DYN_MONOID_PLUGIN.M)

Module DYN_MONOID_PLUGIN.M

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : +M (sidekick.Sidekick_cc.DYN_MONOID_PLUGIN.M)

Module DYN_MONOID_PLUGIN.M

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : CC.t -> state -> E_node.t -> @@ -12,4 +12,4 @@ E_node.t -> t -> Expl.t -> - (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

\ No newline at end of file + (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

diff --git a/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/index.html b/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/index.html index b75d7a92..2676798c 100644 --- a/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/index.html +++ b/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/index.html @@ -1,2 +1,2 @@ -DYN_MONOID_PLUGIN (sidekick.Sidekick_cc.DYN_MONOID_PLUGIN)

Module type Sidekick_cc.DYN_MONOID_PLUGIN

module M : sig ... end
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool

Does the CC E_node.t have a monoid value?

val get : E_node.t -> M.t option

Get monoid value for this CC E_node.t, if any

val iter_all : (CC.repr * M.t) Iter.t
\ No newline at end of file +DYN_MONOID_PLUGIN (sidekick.Sidekick_cc.DYN_MONOID_PLUGIN)

Module type Sidekick_cc.DYN_MONOID_PLUGIN

module M : sig ... end
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool

Does the CC E_node.t have a monoid value?

val get : E_node.t -> M.t option

Get monoid value for this CC E_node.t, if any

val iter_all : (CC.repr * M.t) Iter.t
diff --git a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_ARG/index.html b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_ARG/index.html index 1fe50279..2a71ce38 100644 --- a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_ARG/index.html +++ b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_ARG/index.html @@ -1,5 +1,5 @@ -MONOID_PLUGIN_ARG (sidekick.Sidekick_cc.MONOID_PLUGIN_ARG)

Module type Sidekick_cc.MONOID_PLUGIN_ARG

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : +MONOID_PLUGIN_ARG (sidekick.Sidekick_cc.MONOID_PLUGIN_ARG)

Module type Sidekick_cc.MONOID_PLUGIN_ARG

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : CC.t -> state -> E_node.t -> @@ -12,4 +12,4 @@ E_node.t -> t -> Expl.t -> - (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

\ No newline at end of file + (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

diff --git a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/M/index.html b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/M/index.html index fe7032f2..4ec3e7a4 100644 --- a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/M/index.html +++ b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/M/index.html @@ -1,5 +1,5 @@ -M (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER.M)

Module MONOID_PLUGIN_BUILDER.M

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : +M (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER.M)

Module MONOID_PLUGIN_BUILDER.M

type t

Some type with a monoid structure

include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state

Initialize state from the congruence closure

val name : string

name of the monoid structure (short)

val of_term : CC.t -> state -> E_node.t -> @@ -12,4 +12,4 @@ E_node.t -> t -> Expl.t -> - (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

\ No newline at end of file + (t * CC.Handler_action.t list, CC.Handler_action.conflict) Stdlib.result

Monoidal combination of two values.

merge cc n1 mon1 n2 mon2 expl returns the result of merging monoid values mon1 (for class n1) and mon2 (for class n2) when n1 and n2 are merged with explanation expl.

  • returns

    Ok mon if the merge is acceptable, annotating the class of n1 ∪ n2; or Error expl' if the merge is unsatisfiable. expl' can then be used to trigger a conflict and undo the merge.

diff --git a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/index.html b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/index.html index 0ab26e67..8eeb8b37 100644 --- a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/index.html +++ b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/index.html @@ -1,2 +1,2 @@ -MONOID_PLUGIN_BUILDER (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER)

Module type Sidekick_cc.MONOID_PLUGIN_BUILDER

module M : sig ... end
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t

Create a new monoid state

\ No newline at end of file +MONOID_PLUGIN_BUILDER (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER)

Module type Sidekick_cc.MONOID_PLUGIN_BUILDER

module M : sig ... end
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t

Create a new monoid state

diff --git a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html index 3e75a3d2..7c08e1ab 100644 --- a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html +++ b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html @@ -1,2 +1,2 @@ -DYN_PL_FOR_M (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER.DYN_PL_FOR_M)

Module type MONOID_PLUGIN_BUILDER.DYN_PL_FOR_M

module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool

Does the CC E_node.t have a monoid value?

val get : E_node.t -> M.t option

Get monoid value for this CC E_node.t, if any

val iter_all : (CC.repr * M.t) Iter.t
\ No newline at end of file +DYN_PL_FOR_M (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER.DYN_PL_FOR_M)

Module type MONOID_PLUGIN_BUILDER.DYN_PL_FOR_M

module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool

Does the CC E_node.t have a monoid value?

val get : E_node.t -> M.t option

Get monoid value for this CC E_node.t, if any

val iter_all : (CC.repr * M.t) Iter.t
diff --git a/dev/sidekick/Sidekick_cc_plugin/.dummy b/dev/sidekick/Sidekick_cc_plugin/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_cc_plugin/index.html b/dev/sidekick/Sidekick_cc_plugin/index.html index d4497fbf..ed246f56 100644 --- a/dev/sidekick/Sidekick_cc_plugin/index.html +++ b/dev/sidekick/Sidekick_cc_plugin/index.html @@ -1,2 +1,2 @@ -Sidekick_cc_plugin (sidekick.Sidekick_cc_plugin)

Module Sidekick_cc_plugin

\ No newline at end of file +Sidekick_cc_plugin (sidekick.Sidekick_cc_plugin)

Module Sidekick_cc_plugin

diff --git a/dev/sidekick/Sidekick_core/.dummy b/dev/sidekick/Sidekick_core/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_core/Bool_view/index.html b/dev/sidekick/Sidekick_core/Bool_view/index.html index 5939d3b0..bb4feae5 100644 --- a/dev/sidekick/Sidekick_core/Bool_view/index.html +++ b/dev/sidekick/Sidekick_core/Bool_view/index.html @@ -1,2 +1,2 @@ -Bool_view (sidekick.Sidekick_core.Bool_view)

Module Sidekick_core.Bool_view

Boolean-oriented view of terms

type 'a t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a

View

\ No newline at end of file +Bool_view (sidekick.Sidekick_core.Bool_view)

Module Sidekick_core.Bool_view

Boolean-oriented view of terms

type 'a t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a

View

diff --git a/dev/sidekick/Sidekick_core/Box/index.html b/dev/sidekick/Sidekick_core/Box/index.html index f1a1f1c6..71764eef 100644 --- a/dev/sidekick/Sidekick_core/Box/index.html +++ b/dev/sidekick/Sidekick_core/Box/index.html @@ -1,5 +1,5 @@ -Box (sidekick.Sidekick_core.Box)

Module Sidekick_core.Box

val box : +Box (sidekick.Sidekick_core.Box)

Module Sidekick_core.Box

box tst t makes a new constant that "boxes" t. This way it will be opaque.

val is_box : Sidekick_core_logic.Term.t -> bool
\ No newline at end of file + Sidekick_core_logic.Term.t

box tst t makes a new constant that "boxes" t. This way it will be opaque.

val is_box : Sidekick_core_logic.Term.t -> bool
diff --git a/dev/sidekick/Sidekick_core/CC_view/index.html b/dev/sidekick/Sidekick_core/CC_view/index.html index 486ab7d8..04735893 100644 --- a/dev/sidekick/Sidekick_core/CC_view/index.html +++ b/dev/sidekick/Sidekick_core/CC_view/index.html @@ -1,12 +1,12 @@ -CC_view (sidekick.Sidekick_core.CC_view)

Module Sidekick_core.CC_view

View terms through the lens of a Congruence Closure

type ('f, 't, 'ts) t =
  1. | Bool of bool
  2. | App_fun of 'f * 'ts
  3. | App_ho of 't * 't
  4. | If of 't * 't * 't
  5. | Eq of 't * 't
  6. | Not of 't
  7. | Opaque of 't
    (*

    do not enter

    *)

A view of a term fron the point of view of a congruence closure.

  • 'f is the type of function symbols
  • 't is the type of terms
  • 'ts is the type of sequences of terms (arguments of function application)
val map_view : - f_f:('a -> 'b) -> - f_t:('c -> 'd) -> - f_ts:('e -> 'f) -> +CC_view (sidekick.Sidekick_core.CC_view)

Module Sidekick_core.CC_view

View terms through the lens of a Congruence Closure

type ('f, 't, 'ts) t =
  1. | Bool of bool
  2. | App_fun of 'f * 'ts
  3. | App_ho of 't * 't
  4. | If of 't * 't * 't
  5. | Eq of 't * 't
  6. | Not of 't
  7. | Opaque of 't
    (*

    do not enter

    *)

A view of a term fron the point of view of a congruence closure.

  • 'f is the type of function symbols
  • 't is the type of terms
  • 'ts is the type of sequences of terms (arguments of function application)
val map_view : + f_f:('a -> 'b) -> + f_t:('c -> 'd) -> + f_ts:('e -> 'f) -> ('a, 'c, 'e) t -> ('b, 'd, 'f) t

Map function over a view, one level deep. Each function maps over a different type, e.g. f_t maps over terms

val iter_view : - f_f:('a -> unit) -> - f_t:('b -> unit) -> - f_ts:('c -> unit) -> + f_f:('a -> unit) -> + f_t:('b -> unit) -> + f_ts:('c -> unit) -> ('a, 'b, 'c) t -> - unit

Iterate over a view, one level deep.

\ No newline at end of file + unit

Iterate over a view, one level deep.

diff --git a/dev/sidekick/Sidekick_core/Default_cc_view/index.html b/dev/sidekick/Sidekick_core/Default_cc_view/index.html index 2a6af34f..a642d8b0 100644 --- a/dev/sidekick/Sidekick_core/Default_cc_view/index.html +++ b/dev/sidekick/Sidekick_core/Default_cc_view/index.html @@ -1,7 +1,7 @@ -Default_cc_view (sidekick.Sidekick_core.Default_cc_view)

Module Sidekick_core.Default_cc_view

val view_as_cc : +Default_cc_view (sidekick.Sidekick_core.Default_cc_view)

Module Sidekick_core.Default_cc_view

\ No newline at end of file + CC_view.t
diff --git a/dev/sidekick/Sidekick_core/Gensym/index.html b/dev/sidekick/Sidekick_core/Gensym/index.html index 2c795d92..cfd2b734 100644 --- a/dev/sidekick/Sidekick_core/Gensym/index.html +++ b/dev/sidekick/Sidekick_core/Gensym/index.html @@ -1,2 +1,2 @@ -Gensym (sidekick.Sidekick_core.Gensym)

Module Sidekick_core.Gensym

Fresh symbol generation

type t

Fresh symbol generator.

The theory needs to be able to create new terms with fresh names, to be used as placeholders for complex formulas during Tseitin encoding.

New (stateful) generator instance.

val fresh_term : t -> pre:string -> ty -> term

Make a fresh term of the given type

val reset : t -> unit

Reset to initial state

\ No newline at end of file +Gensym (sidekick.Sidekick_core.Gensym)

Module Sidekick_core.Gensym

Fresh symbol generation

type t

Fresh symbol generator.

The theory needs to be able to create new terms with fresh names, to be used as placeholders for complex formulas during Tseitin encoding.

New (stateful) generator instance.

val fresh_term : t -> pre:string -> ty -> term

Make a fresh term of the given type

val reset : t -> unit

Reset to initial state

diff --git a/dev/sidekick/Sidekick_core/Lit/index.html b/dev/sidekick/Sidekick_core/Lit/index.html index 5b95ca1e..7b3da443 100644 --- a/dev/sidekick/Sidekick_core/Lit/index.html +++ b/dev/sidekick/Sidekick_core/Lit/index.html @@ -1,2 +1,2 @@ -Lit (sidekick.Sidekick_core.Lit)

Module Sidekick_core.Lit

Literals

Literals are a pair of a boolean-sorted term, and a sign. Positive literals are the same as their term, and negative literals are the negation of their term.

The SAT solver deals only in literals and clauses (sets of literals). Everything else belongs in the SMT solver.

type t

A literal

include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp_limit : max_depth:int -> max_nodes:int -> t Sidekick_util.Fmt.printer
val term : t -> term

Get the (positive) term

val sign : t -> bool

Get the sign. A negated literal has sign false.

val neg : t -> t

Take negation of literal. sign (neg lit) = not (sign lit).

val abs : t -> t

abs lit is like lit but always positive, i.e. sign (abs lit) = true

val signed_term : t -> term * bool

Return the atom and the sign

val atom : ?sign:bool -> Sidekick_core_logic.Term.store -> term -> t

atom store t makes a literal out of a term, possibly normalizing its sign in the process.

  • parameter sign

    if provided, and sign=false, negate the resulting lit.

val make_eq : ?sign:bool -> Sidekick_core_logic.Term.store -> term -> term -> t
val norm_sign : t -> t * bool

norm_sign (+t) is +t, true, and norm_sign (-t) is +t, false. In both cases the term is positive, and the boolean reflects the initial sign.

include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
\ No newline at end of file +Lit (sidekick.Sidekick_core.Lit)

Module Sidekick_core.Lit

Literals

Literals are a pair of a boolean-sorted term, and a sign. Positive literals are the same as their term, and negative literals are the negation of their term.

The SAT solver deals only in literals and clauses (sets of literals). Everything else belongs in the SMT solver.

type t

A literal

include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp_limit : max_depth:int -> max_nodes:int -> t Sidekick_util.Fmt.printer
val term : t -> term

Get the (positive) term

val sign : t -> bool

Get the sign. A negated literal has sign false.

val neg : t -> t

Take negation of literal. sign (neg lit) = not (sign lit).

val abs : t -> t

abs lit is like lit but always positive, i.e. sign (abs lit) = true

val signed_term : t -> term * bool

Return the atom and the sign

val atom : ?sign:bool -> Sidekick_core_logic.Term.store -> term -> t

atom store t makes a literal out of a term, possibly normalizing its sign in the process.

  • parameter sign

    if provided, and sign=false, negate the resulting lit.

val make_eq : ?sign:bool -> Sidekick_core_logic.Term.store -> term -> term -> t
val norm_sign : t -> t * bool

norm_sign (+t) is +t, true, and norm_sign (-t) is +t, false. In both cases the term is positive, and the boolean reflects the initial sign.

include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
diff --git a/dev/sidekick/Sidekick_core/Term/Hooks/index.html b/dev/sidekick/Sidekick_core/Term/Hooks/index.html index 9ba0a478..48dc45e2 100644 --- a/dev/sidekick/Sidekick_core/Term/Hooks/index.html +++ b/dev/sidekick/Sidekick_core/Term/Hooks/index.html @@ -1,8 +1,8 @@ -Hooks (sidekick.Sidekick_core.Term.Hooks)

Module Term.Hooks

type t
val empty : t
val add : - (recurse:Sidekick_core_logic.Term.t Sidekick_util.Fmt.printer -> +Hooks (sidekick.Sidekick_core.Term.Hooks)

Module Term.Hooks

type t
val empty : t
val add : + (recurse:Sidekick_core_logic.Term.t Sidekick_util.Fmt.printer -> Sidekick_util.Fmt.t -> Sidekick_core_logic.Term.t -> bool) -> t -> - t
\ No newline at end of file + t
diff --git a/dev/sidekick/Sidekick_core/Term/Ref/index.html b/dev/sidekick/Sidekick_core/Term/Ref/index.html index 33bf166b..07ff070e 100644 --- a/dev/sidekick/Sidekick_core/Term/Ref/index.html +++ b/dev/sidekick/Sidekick_core/Term/Ref/index.html @@ -1,6 +1,6 @@ -Ref (sidekick.Sidekick_core.Term.Ref)

Module Term.Ref

Term reference

Reference to another term, by a unique ID in a trace.

This allows a trace to contain terms with explicit references to other terms, but where these references have to be followed explicitly. Thus, each term can be deserialized separately.

For example, a proof term for a given lemma might use references to previous lemmas, instead of their direct proof terms; this allows a checker or proof GUI to only read this particular lemma's proof into a term.

val ref : +Ref (sidekick.Sidekick_core.Term.Ref)

Module Term.Ref

Term reference

Reference to another term, by a unique ID in a trace.

This allows a trace to contain terms with explicit references to other terms, but where these references have to be followed explicitly. Thus, each term can be deserialized separately.

For example, a proof term for a given lemma might use references to previous lemmas, instead of their direct proof terms; this allows a checker or proof GUI to only read this particular lemma's proof into a term.

ref tst id ~ty is the reference to entry id in a trace, which must be a term of type ty.

val as_ref : Sidekick_core_logic.Term.t -> t option

as_ref (ref tst id ~ty) is Some id.

\ No newline at end of file + ty:Sidekick_core_logic.Term.t -> + Sidekick_core_logic.Term.t

ref tst id ~ty is the reference to entry id in a trace, which must be a term of type ty.

val as_ref : Sidekick_core_logic.Term.t -> t option

as_ref (ref tst id ~ty) is Some id.

diff --git a/dev/sidekick/Sidekick_core/Term/Trace_reader/index.html b/dev/sidekick/Sidekick_core/Term/Trace_reader/index.html index 29aa973b..f986a655 100644 --- a/dev/sidekick/Sidekick_core/Term/Trace_reader/index.html +++ b/dev/sidekick/Sidekick_core/Term/Trace_reader/index.html @@ -1,7 +1,7 @@ -Trace_reader (sidekick.Sidekick_core.Term.Trace_reader)

Module Term.Trace_reader

module Tr = Sidekick_trace
type term_ref = Tr.entry_id
type t
val create : - ?const_decoders:const_decoders list -> - source:Tr.Source.t -> +Trace_reader (sidekick.Sidekick_core.Term.Trace_reader)

Module Term.Trace_reader

module Tr = Sidekick_trace
type term_ref = Tr.entry_id
type t
val create : + ?const_decoders:const_decoders list -> + source:Tr.Source.t -> Sidekick_core_logic.Term.store -> t
val add_const_decoders : t -> const_decoders -> unit
val read_term : t -> @@ -9,4 +9,4 @@ (Sidekick_core_logic.Term.t, string) Stdlib.result
val read_term_err : t -> term_ref -> - (Sidekick_core_logic.Term.t, Sidekick_util.Ser_decode.Error.t) Stdlib.result
val read_term_exn : t -> term_ref -> Sidekick_core_logic.Term.t
  • raises Error.Error

    if it fails

deref_term reader t dereferences the root node of t. If t is Ref id, this returns the term at id instead.

  • raises Error.Error

    if it fails

\ No newline at end of file + (Sidekick_core_logic.Term.t, Sidekick_util.Ser_decode.Error.t) Stdlib.result
val read_term_exn : t -> term_ref -> Sidekick_core_logic.Term.t
  • raises Error.Error

    if it fails

deref_term reader t dereferences the root node of t. If t is Ref id, this returns the term at id instead.

  • raises Error.Error

    if it fails

diff --git a/dev/sidekick/Sidekick_core/Term/Tracer/class-concrete/index.html b/dev/sidekick/Sidekick_core/Term/Tracer/class-concrete/index.html index 6f015f01..86567f2b 100644 --- a/dev/sidekick/Sidekick_core/Term/Tracer/class-concrete/index.html +++ b/dev/sidekick/Sidekick_core/Term/Tracer/class-concrete/index.html @@ -1,2 +1,2 @@ -concrete (sidekick.Sidekick_core.Term.Tracer.concrete)

Class Tracer.concrete

Concrete implementation of t

method emit_term : Sidekick_core_logic.Term.t -> term_ref
\ No newline at end of file +concrete (sidekick.Sidekick_core.Term.Tracer.concrete)

Class Tracer.concrete

Concrete implementation of t

method emit_term : Sidekick_core_logic.Term.t -> term_ref
diff --git a/dev/sidekick/Sidekick_core/Term/Tracer/class-dummy/index.html b/dev/sidekick/Sidekick_core/Term/Tracer/class-dummy/index.html index 718b4e9f..27920680 100644 --- a/dev/sidekick/Sidekick_core/Term/Tracer/class-dummy/index.html +++ b/dev/sidekick/Sidekick_core/Term/Tracer/class-dummy/index.html @@ -1,2 +1,2 @@ -dummy (sidekick.Sidekick_core.Term.Tracer.dummy)

Class Tracer.dummy

Dummy implementation, returns Tr.Entry_id.dummy

inherit t
method emit_term : Sidekick_core_logic.Term.t -> term_ref
\ No newline at end of file +dummy (sidekick.Sidekick_core.Term.Tracer.dummy)

Class Tracer.dummy

Dummy implementation, returns Tr.Entry_id.dummy

inherit t
method emit_term : Sidekick_core_logic.Term.t -> term_ref
diff --git a/dev/sidekick/Sidekick_core/Term/Tracer/class-type-t/index.html b/dev/sidekick/Sidekick_core/Term/Tracer/class-type-t/index.html index 736439c6..dd3aaa0a 100644 --- a/dev/sidekick/Sidekick_core/Term/Tracer/class-type-t/index.html +++ b/dev/sidekick/Sidekick_core/Term/Tracer/class-type-t/index.html @@ -1,2 +1,2 @@ -t (sidekick.Sidekick_core.Term.Tracer.t)

Class type Tracer.t

method emit_term : Sidekick_core_logic.Term.t -> term_ref
\ No newline at end of file +t (sidekick.Sidekick_core.Term.Tracer.t)

Class type Tracer.t

method emit_term : Sidekick_core_logic.Term.t -> term_ref
diff --git a/dev/sidekick/Sidekick_core/Term/Tracer/index.html b/dev/sidekick/Sidekick_core/Term/Tracer/index.html index c7354bcc..ab270f24 100644 --- a/dev/sidekick/Sidekick_core/Term/Tracer/index.html +++ b/dev/sidekick/Sidekick_core/Term/Tracer/index.html @@ -1,2 +1,2 @@ -Tracer (sidekick.Sidekick_core.Term.Tracer)

Module Term.Tracer

Emit terms in traces.

Traces will contains terms, encoded as a DAG. Each subterm is its own event, and gets a term identifier used in other subsequent entries to refer to it.

module Tr = Sidekick_trace
type term_ref = Sidekick_trace.entry_id
class type t = object ... end
class dummy : object ... end

Dummy implementation, returns Tr.Entry_id.dummy

class concrete : sink:Tr.Sink.t -> t

Concrete implementation of t

val create : sink:Tr.Sink.t -> unit -> t

create ~sink () makes a tracer that will write terms into the given sink.

val emit' : t -> Sidekick_core_logic.Term.t -> unit
\ No newline at end of file +Tracer (sidekick.Sidekick_core.Term.Tracer)

Module Term.Tracer

Emit terms in traces.

Traces will contains terms, encoded as a DAG. Each subterm is its own event, and gets a term identifier used in other subsequent entries to refer to it.

module Tr = Sidekick_trace
type term_ref = Sidekick_trace.entry_id
class type t = object ... end
class dummy : object ... end

Dummy implementation, returns Tr.Entry_id.dummy

class concrete : sink:Tr.Sink.t -> t

Concrete implementation of t

val create : sink:Tr.Sink.t -> unit -> t

create ~sink () makes a tracer that will write terms into the given sink.

val emit' : t -> Sidekick_core_logic.Term.t -> unit
diff --git a/dev/sidekick/Sidekick_core/Term/index.html b/dev/sidekick/Sidekick_core/Term/index.html index b3e46d5b..cd5a24b1 100644 --- a/dev/sidekick/Sidekick_core/Term/index.html +++ b/dev/sidekick/Sidekick_core/Term/index.html @@ -1,14 +1,14 @@ -Term (sidekick.Sidekick_core.Term)

Module Sidekick_core.Term

include module type of struct include Sidekick_core_logic.Term end
type t

A term, in the calculus of constructions

The store for terms.

The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).

type view =
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_lam of string * t * t
  6. | E_pi of string * t * t

View.

A view is the shape of the root node of a term.

include Sidekick_sigs.EQ_ORD_HASH with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer

Containers

include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
include Sidekick_sigs.WITH_WEAK with type t := t

Utils

val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> unit

iter_dag t ~f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.

For example, in:

let x = 2 in
+Term (sidekick.Sidekick_core.Term)
Module Sidekick_core.Term
include module type of struct include Sidekick_core_logic.Term end
type t
A term, in the calculus of constructions
The store for terms.
The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
type view = 
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_lam of string * t * t
  6. | E_pi of string * t * t
View.
A view is the shape of the root node of a term.
include Sidekick_sigs.EQ_ORD_HASH with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer
Containers
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
include Sidekick_sigs.WITH_WEAK with type t := t
Utils
val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> unit
iter_dag t ~f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.
For example, in:
let x = 2 in
 let y = f x x in
 let z = g y x in
 z = z
the DAG has the following nodes:
n1: 2
 n2: f n1 n1
 n3: g n2 n1
-n4: = n3 n3
val iter_shallow : f:(bool -> t -> unit) -> t -> unit
iter_shallow f e iterates on immediate subterms of e, calling f trdb e' for each subterm e', with trdb = true iff e' is directly under a binder.
val map_shallow : store -> f:(bool -> t -> t) -> t -> t
val exists_shallow : f:(bool -> t -> bool) -> t -> bool
val for_all_shallow : f:(bool -> t -> bool) -> t -> bool
val contains : t -> sub:t -> bool
val free_vars_iter : t -> var Iter.t
val free_vars : 
-  ?init:Sidekick_core_logic__.Var.Set.t ->
+n4: = n3 n3
val iter_shallow : f:(bool -> t -> unit) -> t -> unit

iter_shallow f e iterates on immediate subterms of e, calling f trdb e' for each subterm e', with trdb = true iff e' is directly under a binder.

val map_shallow : store -> f:(bool -> t -> t) -> t -> t
val exists_shallow : f:(bool -> t -> bool) -> t -> bool
val for_all_shallow : f:(bool -> t -> bool) -> t -> bool
val contains : t -> sub:t -> bool
val free_vars_iter : t -> var Iter.t
val free_vars : + ?init:Sidekick_core_logic__.Var.Set.t -> t -> - Sidekick_core_logic__.Var.Set.t
val is_type : t -> bool

is_type t is true iff view t is Type _

val is_a_type : t -> bool

is_a_type t is true if is_ty (ty t)

val is_closed : t -> bool

Is the term closed (all bound variables are paired with a binder)? time: O(1)

val has_fvars : t -> bool

Does the term contain free variables? time: O(1)

val ty : t -> t

Return the type of this term.

Creation

val type_ : store -> t
val type_of_univ : store -> int -> t
val var : store -> var -> t
val var_str : store -> string -> ty:t -> t
val bvar : store -> bvar -> t
val bvar_i : store -> int -> ty:t -> t
val const : store -> Sidekick_core_logic__.Types_.const -> t
val app : store -> t -> t -> t
val app_l : store -> t -> t list -> t
val app_fold : store -> f:t -> acc0:t -> t list -> t
val lam : store -> var -> t -> t
val pi : store -> var -> t -> t
val arrow : store -> t -> t -> t
val arrow_l : store -> t list -> t -> t
val open_lambda : store -> t -> (var * t) option
val open_lambda_exn : store -> t -> var * t

De bruijn indices

include module type of struct include Sidekick_core_logic.T_builtins end
type Sidekick_core_logic__.Types_.const_view +=
  1. | C_bool
  2. | C_eq
  3. | C_ite
  4. | C_not
  5. | C_true
  6. | C_false
  7. | C_proof
val true_ : Sidekick_core_logic.Term.store -> Sidekick_core_logic.Term.t
val false_ : Sidekick_core_logic.Term.store -> Sidekick_core_logic.Term.t
val bool_val : + Sidekick_core_logic__.Var.Set.t
val is_type : t -> bool

is_type t is true iff view t is Type _

val is_a_type : t -> bool

is_a_type t is true if is_ty (ty t)

val is_closed : t -> bool

Is the term closed (all bound variables are paired with a binder)? time: O(1)

val has_fvars : t -> bool

Does the term contain free variables? time: O(1)

val ty : t -> t

Return the type of this term.

Creation

val type_ : store -> t
val type_of_univ : store -> int -> t
val var : store -> var -> t
val var_str : store -> string -> ty:t -> t
val bvar : store -> bvar -> t
val bvar_i : store -> int -> ty:t -> t
val const : store -> Sidekick_core_logic__.Types_.const -> t
val app : store -> t -> t -> t
val app_l : store -> t -> t list -> t
val app_fold : store -> f:t -> acc0:t -> t list -> t
val lam : store -> var -> t -> t
val pi : store -> var -> t -> t
val arrow : store -> t -> t -> t
val arrow_l : store -> t list -> t -> t
val open_lambda : store -> t -> (var * t) option
val open_lambda_exn : store -> t -> var * t

De bruijn indices

include module type of struct include Sidekick_core_logic.T_builtins end
type Sidekick_core_logic__.Types_.const_view +=
  1. | C_bool
  2. | C_eq
  3. | C_ite
  4. | C_not
  5. | C_true
  6. | C_false
  7. | C_proof
val true_ : Sidekick_core_logic.Term.store -> Sidekick_core_logic.Term.t
val false_ : Sidekick_core_logic.Term.store -> Sidekick_core_logic.Term.t
val eq : @@ -29,7 +29,7 @@ n4: = n3 n3
Sidekick_core_logic.Term.t

abs t returns an "absolute value" for the term, along with the sign of t.

The idea is that we want to turn not a into (false, a), or (a != b) into (false, a=b). For terms without a negation this should return (true, t).

val as_bool_val : Sidekick_core_logic.Term.t -> bool option

open_eq (a=b) returns Some (a,b), None for other terms.

type hook = - recurse:term Sidekick_util.Fmt.printer -> + recurse:term Sidekick_util.Fmt.printer -> Sidekick_util.Fmt.t -> term -> - bool

Printing hook, responsible for printing certain subterms

module Hooks : sig ... end
val default_hooks : Hooks.t Stdlib.ref
val pp_with : Hooks.t -> term Sidekick_util.Fmt.printer

Print using the hooks

val pp : term Sidekick_util.Fmt.printer

Print using default_hooks

val pp_limit : max_depth:int -> max_nodes:int -> term Sidekick_util.Fmt.printer

Print with a limit on the number of nodes printed. An ellipsis is displayed otherwise.

module Tracer : sig ... end

Emit terms in traces.

module Trace_reader : sig ... end
module Ref : sig ... end

Term reference

\ No newline at end of file + bool

Printing hook, responsible for printing certain subterms

module Hooks : sig ... end
val default_hooks : Hooks.t Stdlib.ref
val pp_with : Hooks.t -> term Sidekick_util.Fmt.printer

Print using the hooks

val pp : term Sidekick_util.Fmt.printer

Print using default_hooks

val pp_limit : max_depth:int -> max_nodes:int -> term Sidekick_util.Fmt.printer

Print with a limit on the number of nodes printed. An ellipsis is displayed otherwise.

module Tracer : sig ... end

Emit terms in traces.

module Trace_reader : sig ... end
module Ref : sig ... end

Term reference

diff --git a/dev/sidekick/Sidekick_core/index.html b/dev/sidekick/Sidekick_core/index.html index ba50da87..ebc45b86 100644 --- a/dev/sidekick/Sidekick_core/index.html +++ b/dev/sidekick/Sidekick_core/index.html @@ -1,7 +1,7 @@ -Sidekick_core (sidekick.Sidekick_core)

Module Sidekick_core

Main Signatures.

Theories and concrete solvers rely on an environment that defines several important types:

  • types
  • terms (to represent logic expressions and formulas)
  • a congruence closure instance
  • a bridge to some SAT solver

In this module we define most of the main signatures used throughout Sidekick.

module Fmt = CCFormat

Re-exports from core-logic

module Term : sig ... end

view

module Bool_view : sig ... end

Boolean-oriented view of terms

module CC_view : sig ... end

View terms through the lens of a Congruence Closure

module Default_cc_view : sig ... end

Main modules

module Lit : sig ... end

Literals

module Box : sig ... end
module Gensym : sig ... end

Fresh symbol generation

exception Resource_exhausted

Const decoders for traces

val const_decoders : +Sidekick_core (sidekick.Sidekick_core)

Module Sidekick_core

Main Signatures.

Theories and concrete solvers rely on an environment that defines several important types:

  • types
  • terms (to represent logic expressions and formulas)
  • a congruence closure instance
  • a bridge to some SAT solver

In this module we define most of the main signatures used throughout Sidekick.

module Fmt = CCFormat

Re-exports from core-logic

module Term : sig ... end

view

module Bool_view : sig ... end

Boolean-oriented view of terms

module CC_view : sig ... end

View terms through the lens of a Congruence Closure

module Default_cc_view : sig ... end

Main modules

module Lit : sig ... end

Literals

module Box : sig ... end
module Gensym : sig ... end

Fresh symbol generation

exception Resource_exhausted

Const decoders for traces

val const_decoders : (string * Sidekick_core_logic.Const.Ops.t * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t -> Sidekick_core_logic.Const.view Sidekick_util.Ser_decode.t)) - list
\ No newline at end of file + list
diff --git a/dev/sidekick/Sidekick_core_logic/.dummy b/dev/sidekick/Sidekick_core_logic/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_core_logic/Bvar/index.html b/dev/sidekick/Sidekick_core_logic/Bvar/index.html index d70e6427..568e0a5a 100644 --- a/dev/sidekick/Sidekick_core_logic/Bvar/index.html +++ b/dev/sidekick/Sidekick_core_logic/Bvar/index.html @@ -1,2 +1,2 @@ -Bvar (sidekick.Sidekick_core_logic.Bvar)

Module Sidekick_core_logic.Bvar

Bound variable

type t = {
  1. bv_idx : int;
  2. bv_ty : Sidekick_core_logic__.Types_.term;
}
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val make : int -> Sidekick_core_logic__.Types_.term -> t
val idx : t -> int
val ty : t -> Sidekick_core_logic__.Types_.term
\ No newline at end of file +Bvar (sidekick.Sidekick_core_logic.Bvar)

Module Sidekick_core_logic.Bvar

Bound variable

type t = {
  1. bv_idx : int;
  2. bv_ty : Sidekick_core_logic__.Types_.term;
}
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val make : int -> Sidekick_core_logic__.Types_.term -> t
val idx : t -> int
val ty : t -> Sidekick_core_logic__.Types_.term
diff --git a/dev/sidekick/Sidekick_core_logic/Const/Ops/index.html b/dev/sidekick/Sidekick_core_logic/Const/Ops/index.html index ad030599..520d785c 100644 --- a/dev/sidekick/Sidekick_core_logic/Const/Ops/index.html +++ b/dev/sidekick/Sidekick_core_logic/Const/Ops/index.html @@ -1,6 +1,6 @@ -Ops (sidekick.Sidekick_core_logic.Const.Ops)

Module Const.Ops

type t = {
  1. pp : Sidekick_core_logic__.Types_.const_view Sidekick_util.Fmt.printer;
    (*

    Pretty-print constant

    *)
  2. equal : Sidekick_core_logic__.Types_.const_view -> +Ops (sidekick.Sidekick_core_logic.Const.Ops)

    Module Const.Ops

    type t = {
    1. pp : Sidekick_core_logic__.Types_.const_view Sidekick_util.Fmt.printer;
      (*

      Pretty-print constant

      *)
    2. equal : Sidekick_core_logic__.Types_.const_view -> Sidekick_core_logic__.Types_.const_view -> bool;
      (*

      Equality of constant with any other constant

      *)
    3. hash : Sidekick_core_logic__.Types_.const_view -> int;
      (*

      Hash constant

      *)
    4. ser : (Sidekick_core_logic__.Types_.term -> Sidekick_util.Ser_value.t) -> Sidekick_core_logic__.Types_.const_view -> - string * Sidekick_util.Ser_value.t;
      (*

      Serialize a constant, along with a tag to recognize it.

      *)
    }
    \ No newline at end of file + string * Sidekick_util.Ser_value.t;
    (*

    Serialize a constant, along with a tag to recognize it.

    *)
}
diff --git a/dev/sidekick/Sidekick_core_logic/Const/index.html b/dev/sidekick/Sidekick_core_logic/Const/index.html index 9cb528dc..27fd006d 100644 --- a/dev/sidekick/Sidekick_core_logic/Const/index.html +++ b/dev/sidekick/Sidekick_core_logic/Const/index.html @@ -1,10 +1,10 @@ -Const (sidekick.Sidekick_core_logic.Const)

Module Sidekick_core_logic.Const

Constants.

Constants are logical symbols, defined by the user thanks to an open type

type view = ..
module Ops : sig ... end
type t = {
  1. c_view : view;
  2. c_ops : Ops.t;
  3. c_ty : Sidekick_core_logic__.Types_.term;
}
val view : t -> view
val make : view -> Ops.t -> ty:Sidekick_core_logic__.Types_.term -> t
val ser : - ser_t:(Sidekick_core_logic__.Types_.term -> Sidekick_util.Ser_value.t) -> +Const (sidekick.Sidekick_core_logic.Const)

Module Sidekick_core_logic.Const

Constants.

Constants are logical symbols, defined by the user thanks to an open type

type view = ..
module Ops : sig ... end
type t = {
  1. c_view : view;
  2. c_ops : Ops.t;
  3. c_ty : Sidekick_core_logic__.Types_.term;
}
val view : t -> view
val make : view -> Ops.t -> ty:Sidekick_core_logic__.Types_.term -> t
val ser : + ser_t:(Sidekick_core_logic__.Types_.term -> Sidekick_util.Ser_value.t) -> t -> string * Sidekick_util.Ser_value.t
val ty : t -> Sidekick_core_logic__.Types_.term
type decoders = (string * Ops.t * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t -> view Sidekick_util.Ser_decode.t)) - list

Decoders for constants: given a term store, return a list of supported tags, and for each tag, a decoder for constants that have this particular tag.

include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file + list

Decoders for constants: given a term store, return a list of supported tags, and for each tag, a decoder for constants that have this particular tag.

include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick/Sidekick_core_logic/Str_const/index.html b/dev/sidekick/Sidekick_core_logic/Str_const/index.html index c8145fca..8cff5f41 100644 --- a/dev/sidekick/Sidekick_core_logic/Str_const/index.html +++ b/dev/sidekick/Sidekick_core_logic/Str_const/index.html @@ -1,5 +1,5 @@ -Str_const (sidekick.Sidekick_core_logic.Str_const)

Module Sidekick_core_logic.Str_const

Basic string constants.

These constants are a string name, coupled with a type.

type Sidekick_core_logic__.Types_.const_view +=
  1. | Str of string
val const_decoders : Const.decoders
val make : +Str_const (sidekick.Sidekick_core_logic.Str_const)

Module Sidekick_core_logic.Str_const

Basic string constants.

These constants are a string name, coupled with a type.

type Sidekick_core_logic__.Types_.const_view +=
  1. | Str of string
val const_decoders : Const.decoders
val make : string -> - ty:Sidekick_core_logic__.Types_.term -> - Sidekick_core_logic__.Types_.const
\ No newline at end of file + ty:Sidekick_core_logic__.Types_.term -> + Sidekick_core_logic__.Types_.const
diff --git a/dev/sidekick/Sidekick_core_logic/Subst/index.html b/dev/sidekick/Sidekick_core_logic/Subst/index.html index 43ae235f..ccea90fb 100644 --- a/dev/sidekick/Sidekick_core_logic/Subst/index.html +++ b/dev/sidekick/Sidekick_core_logic/Subst/index.html @@ -1,5 +1,5 @@ -Subst (sidekick.Sidekick_core_logic.Subst)

Module Sidekick_core_logic.Subst

Substitutions

type t
include Sidekick_sigs.PRINT with type t := t
val empty : t
val is_empty : t -> bool
val of_list : +Subst (sidekick.Sidekick_core_logic.Subst)

Module Sidekick_core_logic.Subst

Substitutions

type t
include Sidekick_sigs.PRINT with type t := t
val empty : t
val is_empty : t -> bool
val of_list : (Sidekick_core_logic__.Types_.var * Sidekick_core_logic__.Types_.term) list -> t
val of_iter : (Sidekick_core_logic__.Types_.var * Sidekick_core_logic__.Types_.term) Iter.t -> @@ -11,7 +11,7 @@ t -> t
val apply : Term.store -> - recursive:bool -> + recursive:bool -> t -> Sidekick_core_logic__.Types_.term -> - Sidekick_core_logic__.Types_.term
\ No newline at end of file + Sidekick_core_logic__.Types_.term
diff --git a/dev/sidekick/Sidekick_core_logic/T_builtins/index.html b/dev/sidekick/Sidekick_core_logic/T_builtins/index.html index e605403c..77c4167b 100644 --- a/dev/sidekick/Sidekick_core_logic/T_builtins/index.html +++ b/dev/sidekick/Sidekick_core_logic/T_builtins/index.html @@ -1,2 +1,2 @@ -T_builtins (sidekick.Sidekick_core_logic.T_builtins)

Module Sidekick_core_logic.T_builtins

Core builtins

type Sidekick_core_logic__.Types_.const_view +=
  1. | C_bool
  2. | C_eq
  3. | C_ite
  4. | C_not
  5. | C_true
  6. | C_false
  7. | C_proof
val bool : Term.store -> Term.t
val proof : Term.store -> Term.t
val c_not : Term.store -> Term.t
val c_eq : Term.store -> Term.t
val c_ite : Term.store -> Term.t
val true_ : Term.store -> Term.t
val false_ : Term.store -> Term.t
val bool_val : Term.store -> bool -> Term.t
val const_decoders : Const.decoders
val eq : Term.store -> Term.t -> Term.t -> Term.t

eq a b is a = b

val not : Term.store -> Term.t -> Term.t
val ite : Term.store -> Term.t -> Term.t -> Term.t -> Term.t

ite a b c is if a then b else c

val is_eq : Term.t -> bool
val is_bool : Term.t -> bool
val abs : Term.store -> Term.t -> bool * Term.t

abs t returns an "absolute value" for the term, along with the sign of t.

The idea is that we want to turn not a into (false, a), or (a != b) into (false, a=b). For terms without a negation this should return (true, t).

val as_bool_val : Term.t -> bool option
val open_eq : Term.t -> (Term.t * Term.t) option

open_eq (a=b) returns Some (a,b), None for other terms.

\ No newline at end of file +T_builtins (sidekick.Sidekick_core_logic.T_builtins)

Module Sidekick_core_logic.T_builtins

Core builtins

type Sidekick_core_logic__.Types_.const_view +=
  1. | C_bool
  2. | C_eq
  3. | C_ite
  4. | C_not
  5. | C_true
  6. | C_false
  7. | C_proof
val bool : Term.store -> Term.t
val proof : Term.store -> Term.t
val c_not : Term.store -> Term.t
val c_eq : Term.store -> Term.t
val c_ite : Term.store -> Term.t
val true_ : Term.store -> Term.t
val false_ : Term.store -> Term.t
val bool_val : Term.store -> bool -> Term.t
val const_decoders : Const.decoders
val eq : Term.store -> Term.t -> Term.t -> Term.t

eq a b is a = b

val not : Term.store -> Term.t -> Term.t
val ite : Term.store -> Term.t -> Term.t -> Term.t -> Term.t

ite a b c is if a then b else c

val is_eq : Term.t -> bool
val is_bool : Term.t -> bool
val abs : Term.store -> Term.t -> bool * Term.t

abs t returns an "absolute value" for the term, along with the sign of t.

The idea is that we want to turn not a into (false, a), or (a != b) into (false, a=b). For terms without a negation this should return (true, t).

val as_bool_val : Term.t -> bool option
val open_eq : Term.t -> (Term.t * Term.t) option

open_eq (a=b) returns Some (a,b), None for other terms.

diff --git a/dev/sidekick/Sidekick_core_logic/Term/DB/index.html b/dev/sidekick/Sidekick_core_logic/Term/DB/index.html index c71916c4..08f4cb73 100644 --- a/dev/sidekick/Sidekick_core_logic/Term/DB/index.html +++ b/dev/sidekick/Sidekick_core_logic/Term/DB/index.html @@ -1,2 +1,2 @@ -DB (sidekick.Sidekick_core_logic.Term.DB)

Module Term.DB

De bruijn indices

val lam_db : ?var_name:string -> store -> var_ty:t -> t -> t

lam_db store ~var_ty bod is \ _:var_ty. bod. Not DB shifting is done.

val pi_db : ?var_name:string -> store -> var_ty:t -> t -> t

pi_db store ~var_ty bod is pi _:var_ty. bod. Not DB shifting is done.

val subst_db0 : store -> t -> by:t -> t

subst_db0 store t ~by replaces bound variable 0 in t with the term by. This is useful, for example, to implement beta-reduction.

For example, with t being _[0] = (\x. _[2] _[1] x[0]), subst_db0 store t ~by:"hello" is "hello" = (\x. _[2] "hello" x[0]).

val shift : store -> t -> by:int -> t

shift store t ~by shifts all bound variables in t that are not closed on, by amount by (which must be >= 0).

For example, with term t being \x. _[1] _[2] x[0], shift store t ~by:5 is \x. _[6] _[7] x[0].

val abs_on : store -> var -> t -> t

abs_on store v t is the term t[v := _[0]]. It replaces v with the bound variable with the same type as v, and the DB index 0, and takes care of shifting if v occurs under binders.

For example, abs_on store x (\y. x+y) is \y. _[1] y.

\ No newline at end of file +DB (sidekick.Sidekick_core_logic.Term.DB)

Module Term.DB

De bruijn indices

val lam_db : ?var_name:string -> store -> var_ty:t -> t -> t

lam_db store ~var_ty bod is \ _:var_ty. bod. Not DB shifting is done.

val pi_db : ?var_name:string -> store -> var_ty:t -> t -> t

pi_db store ~var_ty bod is pi _:var_ty. bod. Not DB shifting is done.

val subst_db0 : store -> t -> by:t -> t

subst_db0 store t ~by replaces bound variable 0 in t with the term by. This is useful, for example, to implement beta-reduction.

For example, with t being _[0] = (\x. _[2] _[1] x[0]), subst_db0 store t ~by:"hello" is "hello" = (\x. _[2] "hello" x[0]).

val shift : store -> t -> by:int -> t

shift store t ~by shifts all bound variables in t that are not closed on, by amount by (which must be >= 0).

For example, with term t being \x. _[1] _[2] x[0], shift store t ~by:5 is \x. _[6] _[7] x[0].

val abs_on : store -> var -> t -> t

abs_on store v t is the term t[v := _[0]]. It replaces v with the bound variable with the same type as v, and the DB index 0, and takes care of shifting if v occurs under binders.

For example, abs_on store x (\y. x+y) is \y. _[1] y.

diff --git a/dev/sidekick/Sidekick_core_logic/Term/Store/index.html b/dev/sidekick/Sidekick_core_logic/Term/Store/index.html index c07c2aeb..9ef58146 100644 --- a/dev/sidekick/Sidekick_core_logic/Term/Store/index.html +++ b/dev/sidekick/Sidekick_core_logic/Term/Store/index.html @@ -1,2 +1,2 @@ -Store (sidekick.Sidekick_core_logic.Term.Store)

Module Term.Store

type t = store
val create : ?size:int -> unit -> t
val size : t -> int
\ No newline at end of file +Store (sidekick.Sidekick_core_logic.Term.Store)

Module Term.Store

type t = store
val create : ?size:int -> unit -> t
val size : t -> int
diff --git a/dev/sidekick/Sidekick_core_logic/Term/index.html b/dev/sidekick/Sidekick_core_logic/Term/index.html index cd264271..7c173008 100644 --- a/dev/sidekick/Sidekick_core_logic/Term/index.html +++ b/dev/sidekick/Sidekick_core_logic/Term/index.html @@ -1,11 +1,11 @@ -Term (sidekick.Sidekick_core_logic.Term)

Module Sidekick_core_logic.Term

Core logic terms.

The core terms are expressions in the calculus of constructions, with no universe polymorphism nor cumulativity. It should be fast, with hashconsing; and simple enough (no inductives, no universe trickery).

It is intended to be the foundation for user-level terms and types and formulas.

type var = Var.t
type bvar = Bvar.t
type nonrec term
type t = term

A term, in the calculus of constructions

type store

The store for terms.

The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).

type view =
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_app_fold of {
    1. f : term;
      (*

      function to fold

      *)
    2. args : term list;
      (*

      Arguments to the fold

      *)
    3. acc0 : term;
      (*

      initial accumulator

      *)
    }
  6. | E_lam of string * t * t
  7. | E_pi of string * t * t

View.

A view is the shape of the root node of a term.

include Sidekick_sigs.EQ_ORD_HASH with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer

Containers

include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
include Sidekick_sigs.WITH_WEAK with type t := t
module Weak_set : Stdlib.Weak.S with type data = t
module Weak_map : Stdlib.Ephemeron.S with type key = t

Utils

val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> unit

iter_dag t ~f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.

For example, in:

let x = 2 in
+Term (sidekick.Sidekick_core_logic.Term)
Module Sidekick_core_logic.Term
Core logic terms.
The core terms are expressions in the calculus of constructions, with no universe polymorphism nor cumulativity. It should be fast, with hashconsing; and simple enough (no inductives, no universe trickery).
It is intended to be the foundation for user-level terms and types and formulas.
type var = Var.t
type bvar = Bvar.t
type nonrec term
type t = term
A term, in the calculus of constructions
type store
The store for terms.
The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
type view = 
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_app_fold of {
    1. f : term;
      (*
      function to fold
      *)
    2. args : term list;
      (*
      Arguments to the fold
      *)
    3. acc0 : term;
      (*
      initial accumulator
      *)
    }
  6. | E_lam of string * t * t
  7. | E_pi of string * t * t
View.
A view is the shape of the root node of a term.
include Sidekick_sigs.EQ_ORD_HASH with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer
Containers
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
include Sidekick_sigs.WITH_WEAK with type t := t
module Weak_set : Stdlib.Weak.S with type data = t
module Weak_map : Stdlib.Ephemeron.S with type key = t
Utils
val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> unit
iter_dag t ~f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.
For example, in:
let x = 2 in
 let y = f x x in
 let z = g y x in
 z = z
the DAG has the following nodes:
n1: 2
 n2: f n1 n1
 n3: g n2 n1
-n4: = n3 n3
val iter_shallow : f:(bool -> t -> unit) -> t -> unit
iter_shallow f e iterates on immediate subterms of e, calling f trdb e' for each subterm e', with trdb = true iff e' is directly under a binder.
val map_shallow : store -> f:(bool -> t -> t) -> t -> t
val exists_shallow : f:(bool -> t -> bool) -> t -> bool
val for_all_shallow : f:(bool -> t -> bool) -> t -> bool
val contains : t -> sub:t -> bool
val free_vars_iter : t -> var Iter.t
val free_vars : 
-  ?init:Sidekick_core_logic__.Var.Set.t ->
+n4: = n3 n3
val iter_shallow : f:(bool -> t -> unit) -> t -> unit

iter_shallow f e iterates on immediate subterms of e, calling f trdb e' for each subterm e', with trdb = true iff e' is directly under a binder.

val map_shallow : store -> f:(bool -> t -> t) -> t -> t
val exists_shallow : f:(bool -> t -> bool) -> t -> bool
val for_all_shallow : f:(bool -> t -> bool) -> t -> bool
val contains : t -> sub:t -> bool
val free_vars_iter : t -> var Iter.t
val free_vars : + ?init:Sidekick_core_logic__.Var.Set.t -> t -> - Sidekick_core_logic__.Var.Set.t
val is_type : t -> bool

is_type t is true iff view t is Type _

val is_a_type : t -> bool

is_a_type t is true if is_ty (ty t)

val is_closed : t -> bool

Is the term closed (all bound variables are paired with a binder)? time: O(1)

val has_fvars : t -> bool

Does the term contain free variables? time: O(1)

val ty : t -> t

Return the type of this term.

Creation

module Store : sig ... end
val type_ : store -> t
val type_of_univ : store -> int -> t
val var : store -> var -> t
val var_str : store -> string -> ty:t -> t
val bvar : store -> bvar -> t
val bvar_i : store -> int -> ty:t -> t
val const : store -> Sidekick_core_logic__.Types_.const -> t
val app : store -> t -> t -> t
val app_l : store -> t -> t list -> t
val app_fold : store -> f:t -> acc0:t -> t list -> t
val lam : store -> var -> t -> t
val pi : store -> var -> t -> t
val arrow : store -> t -> t -> t
val arrow_l : store -> t list -> t -> t
val open_lambda : store -> t -> (var * t) option
val open_lambda_exn : store -> t -> var * t
module DB : sig ... end

De bruijn indices

\ No newline at end of file + Sidekick_core_logic__.Var.Set.t
val is_type : t -> bool

is_type t is true iff view t is Type _

val is_a_type : t -> bool

is_a_type t is true if is_ty (ty t)

val is_closed : t -> bool

Is the term closed (all bound variables are paired with a binder)? time: O(1)

val has_fvars : t -> bool

Does the term contain free variables? time: O(1)

val ty : t -> t

Return the type of this term.

Creation

module Store : sig ... end
val type_ : store -> t
val type_of_univ : store -> int -> t
val var : store -> var -> t
val var_str : store -> string -> ty:t -> t
val bvar : store -> bvar -> t
val bvar_i : store -> int -> ty:t -> t
val const : store -> Sidekick_core_logic__.Types_.const -> t
val app : store -> t -> t -> t
val app_l : store -> t -> t list -> t
val app_fold : store -> f:t -> acc0:t -> t list -> t
val lam : store -> var -> t -> t
val pi : store -> var -> t -> t
val arrow : store -> t -> t -> t
val arrow_l : store -> t list -> t -> t
val open_lambda : store -> t -> (var * t) option
val open_lambda_exn : store -> t -> var * t
module DB : sig ... end

De bruijn indices

diff --git a/dev/sidekick/Sidekick_core_logic/Var/index.html b/dev/sidekick/Sidekick_core_logic/Var/index.html index e193dc29..198453d4 100644 --- a/dev/sidekick/Sidekick_core_logic/Var/index.html +++ b/dev/sidekick/Sidekick_core_logic/Var/index.html @@ -1,5 +1,5 @@ -Var (sidekick.Sidekick_core_logic.Var)

Module Sidekick_core_logic.Var

Free variable

type t = {
  1. v_name : string;
  2. v_ty : Sidekick_core_logic__.Types_.term;
}
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp_with_ty : t Sidekick_util.Fmt.printer
val make : string -> Sidekick_core_logic__.Types_.term -> t
val makef : +Var (sidekick.Sidekick_core_logic.Var)

Module Sidekick_core_logic.Var

Free variable

type t = {
  1. v_name : string;
  2. v_ty : Sidekick_core_logic__.Types_.term;
}
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp_with_ty : t Sidekick_util.Fmt.printer
val make : string -> Sidekick_core_logic__.Types_.term -> t
val makef : ('a, Stdlib.Format.formatter, unit, t) Stdlib.format4 -> Sidekick_core_logic__.Types_.term -> - 'a
val name : t -> string
val ty : t -> Sidekick_core_logic__.Types_.term
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
\ No newline at end of file + 'a
val name : t -> string
val ty : t -> Sidekick_core_logic__.Types_.term
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
diff --git a/dev/sidekick/Sidekick_core_logic/index.html b/dev/sidekick/Sidekick_core_logic/index.html index 8c923f3d..022f8423 100644 --- a/dev/sidekick/Sidekick_core_logic/index.html +++ b/dev/sidekick/Sidekick_core_logic/index.html @@ -1,2 +1,2 @@ -Sidekick_core_logic (sidekick.Sidekick_core_logic)

Module Sidekick_core_logic

module Term : sig ... end

Core logic terms.

module Var : sig ... end

Free variable

module Bvar : sig ... end

Bound variable

module Const : sig ... end

Constants.

module Subst : sig ... end

Substitutions

module T_builtins : sig ... end

Core builtins

module Store = Term.Store
module Str_const : sig ... end

Basic string constants.

\ No newline at end of file +Sidekick_core_logic (sidekick.Sidekick_core_logic)

Module Sidekick_core_logic

module Term : sig ... end

Core logic terms.

module Var : sig ... end

Free variable

module Bvar : sig ... end

Bound variable

module Const : sig ... end

Constants.

module Subst : sig ... end

Substitutions

module T_builtins : sig ... end

Core builtins

module Store = Term.Store
module Str_const : sig ... end

Basic string constants.

diff --git a/dev/sidekick/Sidekick_drup/.dummy b/dev/sidekick/Sidekick_drup/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_drup/Make/Atom/index.html b/dev/sidekick/Sidekick_drup/Make/Atom/index.html index b99292de..33fba474 100644 --- a/dev/sidekick/Sidekick_drup/Make/Atom/index.html +++ b/dev/sidekick/Sidekick_drup/Make/Atom/index.html @@ -1,2 +1,2 @@ -Atom (sidekick.Sidekick_drup.Make.Atom)

Module Make.Atom

type t = private int
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val neg : t -> t
val sign : t -> bool
val pp : t Fmt.printer
type atom = t
val of_int_dimacs : int -> t

Turn a signed integer into an atom. Positive integers are positive atoms, and -i is neg (of_int i).

  • raises Invalid_argument

    if the argument is 0

\ No newline at end of file +Atom (sidekick.Sidekick_drup.Make.Atom)

Module Make.Atom

type t = private int
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val neg : t -> t
val sign : t -> bool
val pp : t Fmt.printer
type atom = t
val of_int_dimacs : int -> t

Turn a signed integer into an atom. Positive integers are positive atoms, and -i is neg (of_int i).

  • raises Invalid_argument

    if the argument is 0

diff --git a/dev/sidekick/Sidekick_drup/Make/Checker/index.html b/dev/sidekick/Sidekick_drup/Make/Checker/index.html index 4d221fbb..13ddbf41 100644 --- a/dev/sidekick/Sidekick_drup/Make/Checker/index.html +++ b/dev/sidekick/Sidekick_drup/Make/Checker/index.html @@ -1,2 +1,2 @@ -Checker (sidekick.Sidekick_drup.Make.Checker)

Module Make.Checker

type t
val create : Clause.store -> t
val add_clause : t -> Clause.t -> unit
val is_valid_drup : t -> Clause.t -> bool
val del_clause : t -> Clause.t -> unit
\ No newline at end of file +Checker (sidekick.Sidekick_drup.Make.Checker)

Module Make.Checker

type t
val create : Clause.store -> t
val add_clause : t -> Clause.t -> unit
val is_valid_drup : t -> Clause.t -> bool
val del_clause : t -> Clause.t -> unit
diff --git a/dev/sidekick/Sidekick_drup/Make/Clause/index.html b/dev/sidekick/Sidekick_drup/Make/Clause/index.html index 8a3ec098..d8582b07 100644 --- a/dev/sidekick/Sidekick_drup/Make/Clause/index.html +++ b/dev/sidekick/Sidekick_drup/Make/Clause/index.html @@ -1,2 +1,2 @@ -Clause (sidekick.Sidekick_drup.Make.Clause)

Module Make.Clause

type store
val create : unit -> store
type t
val size : t -> int
val get : t -> int -> atom
val iter : f:(atom -> unit) -> t -> unit
val pp : t Fmt.printer
val of_list : store -> atom list -> t
val of_iter : store -> atom Iter.t -> t
\ No newline at end of file +Clause (sidekick.Sidekick_drup.Make.Clause)

Module Make.Clause

type store
val create : unit -> store
type t
val size : t -> int
val get : t -> int -> atom
val iter : f:(atom -> unit) -> t -> unit
val pp : t Fmt.printer
val of_list : store -> atom list -> t
val of_iter : store -> atom Iter.t -> t
diff --git a/dev/sidekick/Sidekick_drup/Make/index.html b/dev/sidekick/Sidekick_drup/Make/index.html index adae2eb9..ae2fadcc 100644 --- a/dev/sidekick/Sidekick_drup/Make/index.html +++ b/dev/sidekick/Sidekick_drup/Make/index.html @@ -1,2 +1,2 @@ -Make (sidekick.Sidekick_drup.Make)

Module Sidekick_drup.Make

Parameters

Signature

module Atom : sig ... end
type atom = Atom.t
module Clause : sig ... end
type clause = Clause.t
module Checker : sig ... end
\ No newline at end of file +Make (sidekick.Sidekick_drup.Make)

Module Sidekick_drup.Make

Parameters

Signature

module Atom : sig ... end
type atom = Atom.t
module Clause : sig ... end
type clause = Clause.t
module Checker : sig ... end
diff --git a/dev/sidekick/Sidekick_drup/index.html b/dev/sidekick/Sidekick_drup/index.html index 18dd431b..19425be9 100644 --- a/dev/sidekick/Sidekick_drup/index.html +++ b/dev/sidekick/Sidekick_drup/index.html @@ -1,2 +1,2 @@ -Sidekick_drup (sidekick.Sidekick_drup)

Module Sidekick_drup

DRUP trace checker.

This module provides a checker for DRUP traces, including proof_rule-by-proof_rule checking for traces that interleave DRUP steps with other kinds of steps.

module Fmt = CCFormat
module Veci = Sidekick_util.Veci
module type S = sig ... end

An instance of the checker

module Make () : S
\ No newline at end of file +Sidekick_drup (sidekick.Sidekick_drup)

Module Sidekick_drup

DRUP trace checker.

This module provides a checker for DRUP traces, including proof_rule-by-proof_rule checking for traces that interleave DRUP steps with other kinds of steps.

module Fmt = CCFormat
module Veci = Sidekick_util.Veci
module type S = sig ... end

An instance of the checker

module Make () : S
diff --git a/dev/sidekick/Sidekick_drup/module-type-S/Atom/index.html b/dev/sidekick/Sidekick_drup/module-type-S/Atom/index.html index dcd6d897..b5e5b547 100644 --- a/dev/sidekick/Sidekick_drup/module-type-S/Atom/index.html +++ b/dev/sidekick/Sidekick_drup/module-type-S/Atom/index.html @@ -1,2 +1,2 @@ -Atom (sidekick.Sidekick_drup.S.Atom)

Module S.Atom

type t = private int
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val neg : t -> t
val sign : t -> bool
val pp : t Fmt.printer
type atom = t
val of_int_dimacs : int -> t

Turn a signed integer into an atom. Positive integers are positive atoms, and -i is neg (of_int i).

  • raises Invalid_argument

    if the argument is 0

\ No newline at end of file +Atom (sidekick.Sidekick_drup.S.Atom)

Module S.Atom

type t = private int
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val neg : t -> t
val sign : t -> bool
val pp : t Fmt.printer
type atom = t
val of_int_dimacs : int -> t

Turn a signed integer into an atom. Positive integers are positive atoms, and -i is neg (of_int i).

  • raises Invalid_argument

    if the argument is 0

diff --git a/dev/sidekick/Sidekick_drup/module-type-S/Checker/index.html b/dev/sidekick/Sidekick_drup/module-type-S/Checker/index.html index 4badb825..7050654d 100644 --- a/dev/sidekick/Sidekick_drup/module-type-S/Checker/index.html +++ b/dev/sidekick/Sidekick_drup/module-type-S/Checker/index.html @@ -1,2 +1,2 @@ -Checker (sidekick.Sidekick_drup.S.Checker)

Module S.Checker

type t
val create : Clause.store -> t
val add_clause : t -> Clause.t -> unit
val is_valid_drup : t -> Clause.t -> bool
val del_clause : t -> Clause.t -> unit
\ No newline at end of file +Checker (sidekick.Sidekick_drup.S.Checker)

Module S.Checker

type t
val create : Clause.store -> t
val add_clause : t -> Clause.t -> unit
val is_valid_drup : t -> Clause.t -> bool
val del_clause : t -> Clause.t -> unit
diff --git a/dev/sidekick/Sidekick_drup/module-type-S/Clause/index.html b/dev/sidekick/Sidekick_drup/module-type-S/Clause/index.html index cc5906d7..36b13c14 100644 --- a/dev/sidekick/Sidekick_drup/module-type-S/Clause/index.html +++ b/dev/sidekick/Sidekick_drup/module-type-S/Clause/index.html @@ -1,2 +1,2 @@ -Clause (sidekick.Sidekick_drup.S.Clause)

Module S.Clause

type store
val create : unit -> store
type t
val size : t -> int
val get : t -> int -> atom
val iter : f:(atom -> unit) -> t -> unit
val pp : t Fmt.printer
val of_list : store -> atom list -> t
val of_iter : store -> atom Iter.t -> t
\ No newline at end of file +Clause (sidekick.Sidekick_drup.S.Clause)

Module S.Clause

type store
val create : unit -> store
type t
val size : t -> int
val get : t -> int -> atom
val iter : f:(atom -> unit) -> t -> unit
val pp : t Fmt.printer
val of_list : store -> atom list -> t
val of_iter : store -> atom Iter.t -> t
diff --git a/dev/sidekick/Sidekick_drup/module-type-S/index.html b/dev/sidekick/Sidekick_drup/module-type-S/index.html index ed91be6a..9e9d1738 100644 --- a/dev/sidekick/Sidekick_drup/module-type-S/index.html +++ b/dev/sidekick/Sidekick_drup/module-type-S/index.html @@ -1,2 +1,2 @@ -S (sidekick.Sidekick_drup.S)

Module type Sidekick_drup.S

An instance of the checker

module Atom : sig ... end
type atom = Atom.t
module Clause : sig ... end
type clause = Clause.t
module Checker : sig ... end
\ No newline at end of file +S (sidekick.Sidekick_drup.S)

Module type Sidekick_drup.S

An instance of the checker

module Atom : sig ... end
type atom = Atom.t
module Clause : sig ... end
type clause = Clause.t
module Checker : sig ... end
diff --git a/dev/sidekick/Sidekick_memtrace/.dummy b/dev/sidekick/Sidekick_memtrace/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_memtrace/index.html b/dev/sidekick/Sidekick_memtrace/index.html index d740bf75..d5440af3 100644 --- a/dev/sidekick/Sidekick_memtrace/index.html +++ b/dev/sidekick/Sidekick_memtrace/index.html @@ -1,6 +1,6 @@ -Sidekick_memtrace (sidekick.Sidekick_memtrace)

Module Sidekick_memtrace

val trace_if_requested : - ?context:string -> - ?sampling_rate:float -> +Sidekick_memtrace (sidekick.Sidekick_memtrace)

Module Sidekick_memtrace

val trace_if_requested : + ?context:string -> + ?sampling_rate:float -> unit -> - unit
\ No newline at end of file + unit
diff --git a/dev/sidekick/Sidekick_mini_cc/.dummy b/dev/sidekick/Sidekick_mini_cc/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_mini_cc/index.html b/dev/sidekick/Sidekick_mini_cc/index.html index 30ac0d54..62300526 100644 --- a/dev/sidekick/Sidekick_mini_cc/index.html +++ b/dev/sidekick/Sidekick_mini_cc/index.html @@ -1,2 +1,2 @@ -Sidekick_mini_cc (sidekick.Sidekick_mini_cc)

Module Sidekick_mini_cc

Mini congruence closure

This implementation is as simple as possible, and doesn't provide backtracking, theories, or explanations. It just decides the satisfiability of a set of (dis)equations.

module type ARG = sig ... end

Argument for the functor Make

type t

An instance of the congruence closure. Mutable

val create : arg:(module ARG) -> Sidekick_core.Term.store -> t

Instantiate the congruence closure for the given argument structure.

val create_default : Sidekick_core.Term.store -> t

Use the default cc view

val clear : t -> unit

Fully reset the congruence closure's state

val add_lit : t -> Sidekick_core.Term.t -> bool -> unit

add_lit cc p sign asserts that p is true if sign, or p is false if not sign. If p is an equation and sign is true, this adds a new equation to the congruence relation.

val check_sat : t -> bool

check_sat cc returns true if the current state is satisfiable, false if it's unsatisfiable.

val classes : t -> Sidekick_core.Term.t Iter.t Iter.t

Traverse the set of classes in the congruence closure. This should be called only if check returned Sat.

\ No newline at end of file +Sidekick_mini_cc (sidekick.Sidekick_mini_cc)

Module Sidekick_mini_cc

Mini congruence closure

This implementation is as simple as possible, and doesn't provide backtracking, theories, or explanations. It just decides the satisfiability of a set of (dis)equations.

module type ARG = sig ... end

Argument for the functor Make

type t

An instance of the congruence closure. Mutable

val create : arg:(module ARG) -> Sidekick_core.Term.store -> t

Instantiate the congruence closure for the given argument structure.

val create_default : Sidekick_core.Term.store -> t

Use the default cc view

val clear : t -> unit

Fully reset the congruence closure's state

val add_lit : t -> Sidekick_core.Term.t -> bool -> unit

add_lit cc p sign asserts that p is true if sign, or p is false if not sign. If p is an equation and sign is true, this adds a new equation to the congruence relation.

val check_sat : t -> bool

check_sat cc returns true if the current state is satisfiable, false if it's unsatisfiable.

val classes : t -> Sidekick_core.Term.t Iter.t Iter.t

Traverse the set of classes in the congruence closure. This should be called only if check returned Sat.

diff --git a/dev/sidekick/Sidekick_mini_cc/module-type-ARG/index.html b/dev/sidekick/Sidekick_mini_cc/module-type-ARG/index.html index ebe9b60a..befb7562 100644 --- a/dev/sidekick/Sidekick_mini_cc/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_mini_cc/module-type-ARG/index.html @@ -1,5 +1,5 @@ -ARG (sidekick.Sidekick_mini_cc.ARG)

Module type Sidekick_mini_cc.ARG

Argument for the functor Make

It only requires a Term.t structure, and a congruence-oriented view.

val view_as_cc : +ARG (sidekick.Sidekick_mini_cc.ARG)

Module type Sidekick_mini_cc.ARG

Argument for the functor Make

It only requires a Term.t structure, and a congruence-oriented view.

\ No newline at end of file + Sidekick_core.CC_view.t
diff --git a/dev/sidekick/Sidekick_proof/.dummy b/dev/sidekick/Sidekick_proof/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_proof/Core_rules/index.html b/dev/sidekick/Sidekick_proof/Core_rules/index.html index 9f48496b..94d5c6ec 100644 --- a/dev/sidekick/Sidekick_proof/Core_rules/index.html +++ b/dev/sidekick/Sidekick_proof/Core_rules/index.html @@ -1,17 +1,17 @@ -Core_rules (sidekick.Sidekick_proof.Core_rules)

Module Sidekick_proof.Core_rules

Core proofs for SMT and congruence closure.

val lemma_cc : lit list -> Pterm.t

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : +Core_rules (sidekick.Sidekick_proof.Core_rules)

Module Sidekick_proof.Core_rules

Core proofs for SMT and congruence closure.

val lemma_cc : lit list -> Pterm.t

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : Pterm.step_id -> Pterm.step_id -> Pterm.t

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the Pterm.t that produces C \/ u, i.e unit paramodulation.

val proof_r1 : Pterm.step_id -> Pterm.step_id -> Pterm.t

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the Pterm.t that produces C \/ u, i.e unit resolution.

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the Pterm.t that produces C \/ D, i.e boolean resolution.

val with_defs : Pterm.step_id -> Pterm.step_id list -> Pterm.t

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : Sidekick_core_logic.Term.t -> Sidekick_core_logic.Term.t -> - using:Pterm.step_id list -> + using:Pterm.step_id list -> Pterm.t

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a Pterm.t ID for the clause (t=u).

val lemma_rw_clause : Pterm.step_id -> - res:lit list -> - using:Pterm.step_id list -> - Pterm.t

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file + res:lit list -> + using:Pterm.step_id list -> + Pterm.t

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

diff --git a/dev/sidekick/Sidekick_proof/Pterm/index.html b/dev/sidekick/Sidekick_proof/Pterm/index.html index 95d97494..1d83f518 100644 --- a/dev/sidekick/Sidekick_proof/Pterm/index.html +++ b/dev/sidekick/Sidekick_proof/Pterm/index.html @@ -1,9 +1,9 @@ -Pterm (sidekick.Sidekick_proof.Pterm)

Module Sidekick_proof.Pterm

Proof terms.

A proof term is the description of a reasoning step, that yields a clause.

type step_id = Step.id
type local_ref = Step.id

A local reference is a step id that is only valid in the scope of a P_let. Typically one can use negative integers to avoid accidental shadowing.

type rule_apply = {
  1. rule_name : string;
  2. lit_args : lit list;
  3. term_args : Sidekick_core.Term.t list;
  4. subst_args : Sidekick_core.Subst.t list;
  5. premises : step_id list;
  6. indices : int list;
}
type t =
  1. | P_ref of step_id
  2. | P_local of local_ref
    (*

    Local reference, in a let

    *)
  3. | P_let of (local_ref * t) list * t
  4. | P_apply of rule_apply
type delayed = unit -> t
include Sidekick_sigs.PRINT with type t := t
val ref : step_id -> t
val local_ref : local_ref -> t
val let_ : (local_ref * t) list -> t -> t
val delay : (unit -> t) -> delayed
val dummy : t

Reference to the dummy step

val apply_rule : - ?lits:lit list -> - ?terms:Sidekick_core.Term.t list -> - ?substs:Sidekick_core.Subst.t list -> - ?premises:step_id list -> - ?indices:int list -> +Pterm (sidekick.Sidekick_proof.Pterm)

Module Sidekick_proof.Pterm

Proof terms.

A proof term is the description of a reasoning step, that yields a clause.

type step_id = Step.id
type local_ref = Step.id

A local reference is a step id that is only valid in the scope of a P_let. Typically one can use negative integers to avoid accidental shadowing.

type rule_apply = {
  1. rule_name : string;
  2. lit_args : lit list;
  3. term_args : Sidekick_core.Term.t list;
  4. subst_args : Sidekick_core.Subst.t list;
  5. premises : step_id list;
  6. indices : int list;
}
type t =
  1. | P_ref of step_id
  2. | P_local of local_ref
    (*

    Local reference, in a let

    *)
  3. | P_let of (local_ref * t) list * t
  4. | P_apply of rule_apply
type delayed = unit -> t
include Sidekick_sigs.PRINT with type t := t
val ref : step_id -> t
val local_ref : local_ref -> t
val let_ : (local_ref * t) list -> t -> t
val delay : (unit -> t) -> delayed
val dummy : t

Reference to the dummy step

val apply_rule : + ?lits:lit list -> + ?terms:Sidekick_core.Term.t list -> + ?substs:Sidekick_core.Subst.t list -> + ?premises:step_id list -> + ?indices:int list -> string -> - t

Serialize

\ No newline at end of file + t

Serialize

diff --git a/dev/sidekick/Sidekick_proof/Sat_rules/index.html b/dev/sidekick/Sidekick_proof/Sat_rules/index.html index 825e3108..2082bdc3 100644 --- a/dev/sidekick/Sidekick_proof/Sat_rules/index.html +++ b/dev/sidekick/Sidekick_proof/Sat_rules/index.html @@ -1,2 +1,2 @@ -Sat_rules (sidekick.Sidekick_proof.Sat_rules)

Module Sidekick_proof.Sat_rules

SAT-solver proof emission.

val sat_input_clause : lit list -> Pterm.t

Emit an input clause.

val sat_redundant_clause : lit list -> hyps:Step.id Iter.t -> Pterm.t

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val sat_unsat_core : lit list -> Pterm.t

TODO: is this relevant here?

\ No newline at end of file +Sat_rules (sidekick.Sidekick_proof.Sat_rules)

Module Sidekick_proof.Sat_rules

SAT-solver proof emission.

val sat_input_clause : lit list -> Pterm.t

Emit an input clause.

val sat_redundant_clause : lit list -> hyps:Step.id Iter.t -> Pterm.t

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val sat_unsat_core : lit list -> Pterm.t

TODO: is this relevant here?

diff --git a/dev/sidekick/Sidekick_proof/Step/index.html b/dev/sidekick/Sidekick_proof/Step/index.html index 4f7fc149..fc2d1054 100644 --- a/dev/sidekick/Sidekick_proof/Step/index.html +++ b/dev/sidekick/Sidekick_proof/Step/index.html @@ -1,2 +1,2 @@ -Step (sidekick.Sidekick_proof.Step)

Module Sidekick_proof.Step

val equal : id -> id -> bool
val dummy : id
val pp : id Sidekick_core.Fmt.printer
\ No newline at end of file +Step (sidekick.Sidekick_proof.Step)

Module Sidekick_proof.Step

val equal : id -> id -> bool
val dummy : id
val pp : id Sidekick_core.Fmt.printer
diff --git a/dev/sidekick/Sidekick_proof/Step_vec/index.html b/dev/sidekick/Sidekick_proof/Step_vec/index.html index 11cf064f..c266c8f8 100644 --- a/dev/sidekick/Sidekick_proof/Step_vec/index.html +++ b/dev/sidekick/Sidekick_proof/Step_vec/index.html @@ -1,2 +1,2 @@ -Step_vec (sidekick.Sidekick_proof.Step_vec)

Module Sidekick_proof.Step_vec

A vector indexed by steps.

include Sidekick_util.Vec_sig.BASE with type elt = Step.id
include Sidekick_util.Vec_sig.BASE_RO with type elt = Step.id
type elt = Step.id
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (elt -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
\ No newline at end of file +Step_vec (sidekick.Sidekick_proof.Step_vec)

Module Sidekick_proof.Step_vec

A vector indexed by steps.

include Sidekick_util.Vec_sig.BASE with type elt = Step.id
include Sidekick_util.Vec_sig.BASE_RO with type elt = Step.id
type elt = Step.id
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (elt -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
diff --git a/dev/sidekick/Sidekick_proof/Trace_reader/index.html b/dev/sidekick/Sidekick_proof/Trace_reader/index.html index 07c79c69..b4ea9c31 100644 --- a/dev/sidekick/Sidekick_proof/Trace_reader/index.html +++ b/dev/sidekick/Sidekick_proof/Trace_reader/index.html @@ -1,6 +1,6 @@ -Trace_reader (sidekick.Sidekick_proof.Trace_reader)

Module Sidekick_proof.Trace_reader

module Tr = Sidekick_trace
type step_id = Step.id
type t
val read_step : - ?fix:bool -> +Trace_reader (sidekick.Sidekick_proof.Trace_reader)

Module Sidekick_proof.Trace_reader

module Tr = Sidekick_trace
type step_id = Step.id
type t
val read_step : + ?fix:bool -> t -> step_id -> - (Pterm.t, Dec.Error.t) Stdlib.result

Read a step from the source at the given step id, using the trace reader.

  • parameter fix

    if true, dereferences in a loop so the returned proof term is not a Ref.

val dec_step_id : ?fix:bool -> t -> Pterm.t Dec.t

Reads an integer, decodes the corresponding entry

\ No newline at end of file + (Pterm.t, Dec.Error.t) Stdlib.result

Read a step from the source at the given step id, using the trace reader.

  • parameter fix

    if true, dereferences in a loop so the returned proof term is not a Ref.

val dec_step_id : ?fix:bool -> t -> Pterm.t Dec.t

Reads an integer, decodes the corresponding entry

diff --git a/dev/sidekick/Sidekick_proof/Tracer/class-concrete/index.html b/dev/sidekick/Sidekick_proof/Tracer/class-concrete/index.html index 6e8eaec9..445b83db 100644 --- a/dev/sidekick/Sidekick_proof/Tracer/class-concrete/index.html +++ b/dev/sidekick/Sidekick_proof/Tracer/class-concrete/index.html @@ -1,2 +1,2 @@ -concrete (sidekick.Sidekick_proof.Tracer.concrete)

Class Tracer.concrete

Concrete implementation of t

inherit Sidekick_core.Term.Tracer.t
method proof_enabled : bool

If proof tracing enabled?

method proof_enable : bool -> unit

Enable/disable proof tracing, if supported

method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id

Create a new step in the trace.

method emit_proof_delete : step_id -> unit

Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.

\ No newline at end of file +concrete (sidekick.Sidekick_proof.Tracer.concrete)

Class Tracer.concrete

Concrete implementation of t

inherit Sidekick_core.Term.Tracer.t
method proof_enabled : bool

If proof tracing enabled?

method proof_enable : bool -> unit

Enable/disable proof tracing, if supported

method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id

Create a new step in the trace.

method emit_proof_delete : step_id -> unit

Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.

diff --git a/dev/sidekick/Sidekick_proof/Tracer/class-dummy/index.html b/dev/sidekick/Sidekick_proof/Tracer/class-dummy/index.html index 3512a4b9..8a5ec9df 100644 --- a/dev/sidekick/Sidekick_proof/Tracer/class-dummy/index.html +++ b/dev/sidekick/Sidekick_proof/Tracer/class-dummy/index.html @@ -1,2 +1,2 @@ -dummy (sidekick.Sidekick_proof.Tracer.dummy)

Class Tracer.dummy

Dummy proof trace, logs nothing.

inherit Sidekick_core.Term.Tracer.t
method proof_enabled : bool

If proof tracing enabled?

method proof_enable : bool -> unit

Enable/disable proof tracing, if supported

method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id

Create a new step in the trace.

method emit_proof_delete : step_id -> unit

Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.

\ No newline at end of file +dummy (sidekick.Sidekick_proof.Tracer.dummy)

Class Tracer.dummy

Dummy proof trace, logs nothing.

inherit Sidekick_core.Term.Tracer.t
method proof_enabled : bool

If proof tracing enabled?

method proof_enable : bool -> unit

Enable/disable proof tracing, if supported

method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id

Create a new step in the trace.

method emit_proof_delete : step_id -> unit

Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.

diff --git a/dev/sidekick/Sidekick_proof/Tracer/class-type-t/index.html b/dev/sidekick/Sidekick_proof/Tracer/class-type-t/index.html index e65f221c..0178041a 100644 --- a/dev/sidekick/Sidekick_proof/Tracer/class-type-t/index.html +++ b/dev/sidekick/Sidekick_proof/Tracer/class-type-t/index.html @@ -1,2 +1,2 @@ -t (sidekick.Sidekick_proof.Tracer.t)

Class type Tracer.t

A proof tracer.

A proof tracer builds a log of all deductive steps taken by the solver, so we can later reconstruct a certificate for proof-checking.

Each step in the proof trace should be a valid lemma (of its theory) or a valid consequence of previous steps.

inherit Sidekick_core.Term.Tracer.t
method proof_enabled : bool

If proof tracing enabled?

method proof_enable : bool -> unit

Enable/disable proof tracing, if supported

method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id

Create a new step in the trace.

method emit_proof_delete : step_id -> unit

Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.

\ No newline at end of file +t (sidekick.Sidekick_proof.Tracer.t)

Class type Tracer.t

A proof tracer.

A proof tracer builds a log of all deductive steps taken by the solver, so we can later reconstruct a certificate for proof-checking.

Each step in the proof trace should be a valid lemma (of its theory) or a valid consequence of previous steps.

inherit Sidekick_core.Term.Tracer.t
method proof_enabled : bool

If proof tracing enabled?

method proof_enable : bool -> unit

Enable/disable proof tracing, if supported

method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id

Create a new step in the trace.

method emit_proof_delete : step_id -> unit

Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.

diff --git a/dev/sidekick/Sidekick_proof/Tracer/index.html b/dev/sidekick/Sidekick_proof/Tracer/index.html index d77a211b..e5bed275 100644 --- a/dev/sidekick/Sidekick_proof/Tracer/index.html +++ b/dev/sidekick/Sidekick_proof/Tracer/index.html @@ -1,2 +1,2 @@ -Tracer (sidekick.Sidekick_proof.Tracer)

Module Sidekick_proof.Tracer

Proof traces.

A proof trace is a log of all the deductive reasoning steps made by the SMT solver and other reasoning components. It essentially stores a DAG of all these steps, where each step points (via step_id) to its premises.

type step_id = Step.id

Identifier for a tracing step (like a unique ID for a clause previously added/proved)

class type t = object ... end

A proof tracer.

val enabled : t -> bool

Is proof tracing enabled?

val enable : t -> bool -> unit

Enable proof tracing

val add_step : t -> Pterm.delayed -> step_id

Create a new step in the trace.

val delete : t -> step_id -> unit

Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.

class dummy : t

Dummy proof trace, logs nothing.

val dummy : t

Concrete implementation of t

\ No newline at end of file +Tracer (sidekick.Sidekick_proof.Tracer)

Module Sidekick_proof.Tracer

Proof traces.

A proof trace is a log of all the deductive reasoning steps made by the SMT solver and other reasoning components. It essentially stores a DAG of all these steps, where each step points (via step_id) to its premises.

type step_id = Step.id

Identifier for a tracing step (like a unique ID for a clause previously added/proved)

class type t = object ... end

A proof tracer.

val enabled : t -> bool

Is proof tracing enabled?

val enable : t -> bool -> unit

Enable proof tracing

val add_step : t -> Pterm.delayed -> step_id

Create a new step in the trace.

val delete : t -> step_id -> unit

Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.

class dummy : t

Dummy proof trace, logs nothing.

val dummy : t

Concrete implementation of t

diff --git a/dev/sidekick/Sidekick_proof/index.html b/dev/sidekick/Sidekick_proof/index.html index dc3c5ad7..d0941946 100644 --- a/dev/sidekick/Sidekick_proof/index.html +++ b/dev/sidekick/Sidekick_proof/index.html @@ -1,2 +1,2 @@ -Sidekick_proof (sidekick.Sidekick_proof)

Module Sidekick_proof

module Step : sig ... end
module Step_vec : sig ... end

A vector indexed by steps.

module Sat_rules : sig ... end

SAT-solver proof emission.

module Core_rules : sig ... end

Core proofs for SMT and congruence closure.

module Pterm : sig ... end

Proof terms.

module Tracer : sig ... end

Proof traces.

module Trace_reader : sig ... end
module Arg = Stdlib.Arg
type term = Pterm.t
type term_ref = Step.id
type step_id = Step.id
\ No newline at end of file +Sidekick_proof (sidekick.Sidekick_proof)

Module Sidekick_proof

module Step : sig ... end
module Step_vec : sig ... end

A vector indexed by steps.

module Sat_rules : sig ... end

SAT-solver proof emission.

module Core_rules : sig ... end

Core proofs for SMT and congruence closure.

module Pterm : sig ... end

Proof terms.

module Tracer : sig ... end

Proof traces.

module Trace_reader : sig ... end
module Arg = Stdlib.Arg
type term = Pterm.t
type term_ref = Step.id
type step_id = Step.id
diff --git a/dev/sidekick/Sidekick_quip/.dummy b/dev/sidekick/Sidekick_quip/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_quip/Proof/Fun/index.html b/dev/sidekick/Sidekick_quip/Proof/Fun/index.html index 532c0ad4..10c4b25c 100644 --- a/dev/sidekick/Sidekick_quip/Proof/Fun/index.html +++ b/dev/sidekick/Sidekick_quip/Proof/Fun/index.html @@ -1,2 +1,2 @@ -Fun (sidekick.Sidekick_quip.Proof.Fun)

Module Proof.Fun

type t = string
val pp : Sidekick_util.Fmt.t -> t -> unit
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file +Fun (sidekick.Sidekick_quip.Proof.Fun)

Module Proof.Fun

type t = string
val pp : Sidekick_util.Fmt.t -> t -> unit
val equal : t -> t -> bool
val hash : t -> int
diff --git a/dev/sidekick/Sidekick_quip/Proof/Lit/index.html b/dev/sidekick/Sidekick_quip/Proof/Lit/index.html index 5c64e48b..a78f81e5 100644 --- a/dev/sidekick/Sidekick_quip/Proof/Lit/index.html +++ b/dev/sidekick/Sidekick_quip/Proof/Lit/index.html @@ -1,6 +1,6 @@ -Lit (sidekick.Sidekick_quip.Proof.Lit)

Module Proof.Lit

type t =
  1. | L_eq of term * term
  2. | L_a of bool * term
val pp_with : - pp_t:(Sidekick_util.Fmt.t -> term -> unit) -> +Lit (sidekick.Sidekick_quip.Proof.Lit)

Module Proof.Lit

type t =
  1. | L_eq of term * term
  2. | L_a of bool * term
val pp_with : + pp_t:(Sidekick_util.Fmt.t -> term -> unit) -> Sidekick_util.Fmt.t -> t -> - unit
val pp : Sidekick_util.Fmt.t -> t -> unit
val eq : term -> term -> t
val mk : bool -> term -> t
\ No newline at end of file + unit
val pp : Sidekick_util.Fmt.t -> t -> unit
val eq : term -> term -> t
val mk : bool -> term -> t
diff --git a/dev/sidekick/Sidekick_quip/Proof/T/index.html b/dev/sidekick/Sidekick_quip/Proof/T/index.html index b6b060da..f18326e7 100644 --- a/dev/sidekick/Sidekick_quip/Proof/T/index.html +++ b/dev/sidekick/Sidekick_quip/Proof/T/index.html @@ -1,2 +1,2 @@ -T (sidekick.Sidekick_quip.Proof.T)

Module Proof.T

Representation of terms, with explicit sharing

type t =
  1. | Bool of bool
  2. | App_fun of Fun.t * t array
  3. | App_ho of t * t
  4. | Is_a of Fun.t * t
  5. | Ite of t * t * t
  6. | Not of t
  7. | Eq of t * t
  8. | Ref of string
val view : t -> t
val equal : t -> t -> bool
val hash : t -> int
val true_ : t
val false_ : t
val bool : bool -> t
val not_ : t -> t
val eq : t -> t -> t
val ref : string -> t
val app_fun : Fun.t -> t array -> t
val const : Fun.t -> t
val app_ho : t -> t -> t
val ite : t -> t -> t -> t
val is_a : Fun.t -> t -> t
\ No newline at end of file +T (sidekick.Sidekick_quip.Proof.T)

Module Proof.T

Representation of terms, with explicit sharing

type t =
  1. | Bool of bool
  2. | App_fun of Fun.t * t array
  3. | App_ho of t * t
  4. | Is_a of Fun.t * t
  5. | Ite of t * t * t
  6. | Not of t
  7. | Eq of t * t
  8. | Ref of string
val view : t -> t
val equal : t -> t -> bool
val hash : t -> int
val true_ : t
val false_ : t
val bool : bool -> t
val not_ : t -> t
val eq : t -> t -> t
val ref : string -> t
val app_fun : Fun.t -> t array -> t
val const : Fun.t -> t
val app_ho : t -> t -> t
val ite : t -> t -> t -> t
val is_a : Fun.t -> t -> t
diff --git a/dev/sidekick/Sidekick_quip/Proof/Ty/index.html b/dev/sidekick/Sidekick_quip/Proof/Ty/index.html index 7bb18230..cf2af744 100644 --- a/dev/sidekick/Sidekick_quip/Proof/Ty/index.html +++ b/dev/sidekick/Sidekick_quip/Proof/Ty/index.html @@ -1,2 +1,2 @@ -Ty (sidekick.Sidekick_quip.Proof.Ty)

Module Proof.Ty

Representation of types

type t =
  1. | Bool
  2. | Arrow of t array * t
  3. | App of string * t array
  4. | Ref of string
val equal : t -> t -> bool
val hash : t -> int
val view : t -> t
\ No newline at end of file +Ty (sidekick.Sidekick_quip.Proof.Ty)

Module Proof.Ty

Representation of types

type t =
  1. | Bool
  2. | Arrow of t array * t
  3. | App of string * t array
  4. | Ref of string
val equal : t -> t -> bool
val hash : t -> int
val view : t -> t
diff --git a/dev/sidekick/Sidekick_quip/Proof/index.html b/dev/sidekick/Sidekick_quip/Proof/index.html index 1e0ea31e..390a1b49 100644 --- a/dev/sidekick/Sidekick_quip/Proof/index.html +++ b/dev/sidekick/Sidekick_quip/Proof/index.html @@ -1,2 +1,2 @@ -Proof (sidekick.Sidekick_quip.Proof)

Module Sidekick_quip.Proof

type id = int

A reference to a previously defined object in the proof

module Ty : sig ... end

Representation of types

module Fun : sig ... end
module Cstor = Fun
module T : sig ... end

Representation of terms, with explicit sharing

type term = T.t
type ty = Ty.t
module Lit : sig ... end
type clause = Lit.t list
type t =
  1. | Unspecified
  2. | Sorry
  3. | Sorry_c of clause
  4. | Named of string
  5. | Refl of term
  6. | CC_lemma_imply of t list * term * term
  7. | CC_lemma of clause
  8. | Assertion of term
  9. | Assertion_c of clause
  10. | Hres of t * hres_step list
  11. | Res of term * t * t
  12. | Res1 of t * t
  13. | Paramod1 of t * t
  14. | Rup of clause * t list
  15. | Clause_rw of {
    1. res : clause;
    2. c0 : t;
    3. using : t list;
      (*

      the rewriting equations/atoms

      *)
    }
  16. | DT_isa_split of ty * term list
  17. | DT_isa_disj of ty * term * term
  18. | DT_cstor_inj of Cstor.t * int * term list * term list
  19. | Bool_true_is_true
  20. | Bool_true_neq_false
  21. | Bool_eq of term * term
  22. | Bool_c of bool_c_name * term list
  23. | Ite_true of term
  24. | Ite_false of term
  25. | LRA of clause
  26. | Composite of {
    1. assumptions : (string * Lit.t) list;
    2. steps : composite_step array;
    }
and bool_c_name = string
and composite_step =
  1. | S_step_c of {
    1. name : string;
    2. res : clause;
    3. proof : t;
    }
    (*

    A named step in Composite, with the expected result. This decouples the checking of the sub-proof, from its use in the rest of the proof, as we can use res even if checking proof failed.

    *)
  2. | S_step_anon of {
    1. name : string;
    2. proof : t;
    }
    (*

    A named intermediate proof, to be reused in subsequent proofs. Unlike S_step_c we do not specify the expected result so if this fails, any proof downstream will also fail.

    *)
  3. | S_define_t of term * term
  4. | S_define_t_name of string * term
and hres_step =
  1. | R of {
    1. pivot : term;
    2. p : t;
    }
  2. | R1 of t
  3. | P of {
    1. lhs : term;
    2. rhs : term;
    3. p : t;
    }
  4. | P1 of t
val r : t -> pivot:term -> hres_step
val r1 : t -> hres_step
val p : t -> lhs:term -> rhs:term -> hres_step
val p1 : t -> hres_step
val stepc : name:string -> clause -> t -> composite_step
val step_anon : name:string -> t -> composite_step
val deft : term -> term -> composite_step
val deft_name : string -> term -> composite_step
val is_trivial_refl : t -> bool
val default : t
val sorry_c : Lit.t Iter.t -> t
val sorry_c_l : clause -> t
val sorry : t
val refl : term -> t
val ref_by_name : string -> t
val cc_lemma : clause -> t
val cc_imply_l : t list -> term -> term -> t
val cc_imply2 : t -> t -> term -> term -> t
val assertion : term -> t
val assertion_c : Lit.t Iter.t -> t
val assertion_c_l : clause -> t
val rup : clause -> t list -> t
val clause_rw : t -> res:clause -> using:t list -> t
val composite_a : ?assms:(string * Lit.t) list -> composite_step array -> t
val composite_l : ?assms:(string * Lit.t) list -> composite_step list -> t
val composite_iter : ?assms:(string * Lit.t) list -> composite_step Iter.t -> t
val isa_split : ty -> term Iter.t -> t
val isa_disj : ty -> term -> term -> t
val cstor_inj : Cstor.t -> int -> term list -> term list -> t
val ite_true : term -> t
val ite_false : term -> t
val true_is_true : t
val true_neq_false : t
val bool_eq : term -> term -> t
val bool_c : bool_c_name -> term list -> t
val hres_l : t -> hres_step list -> t
val hres_iter : t -> hres_step Iter.t -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val paramod1 : t -> t -> t
val lra_l : clause -> t
val lra : Lit.t Iter.t -> t
\ No newline at end of file +Proof (sidekick.Sidekick_quip.Proof)

Module Sidekick_quip.Proof

type id = int

A reference to a previously defined object in the proof

module Ty : sig ... end

Representation of types

module Fun : sig ... end
module Cstor = Fun
module T : sig ... end

Representation of terms, with explicit sharing

type term = T.t
type ty = Ty.t
module Lit : sig ... end
type clause = Lit.t list
type t =
  1. | Unspecified
  2. | Sorry
  3. | Sorry_c of clause
  4. | Named of string
  5. | Refl of term
  6. | CC_lemma_imply of t list * term * term
  7. | CC_lemma of clause
  8. | Assertion of term
  9. | Assertion_c of clause
  10. | Hres of t * hres_step list
  11. | Res of term * t * t
  12. | Res1 of t * t
  13. | Paramod1 of t * t
  14. | Rup of clause * t list
  15. | Clause_rw of {
    1. res : clause;
    2. c0 : t;
    3. using : t list;
      (*

      the rewriting equations/atoms

      *)
    }
  16. | DT_isa_split of ty * term list
  17. | DT_isa_disj of ty * term * term
  18. | DT_cstor_inj of Cstor.t * int * term list * term list
  19. | Bool_true_is_true
  20. | Bool_true_neq_false
  21. | Bool_eq of term * term
  22. | Bool_c of bool_c_name * term list
  23. | Ite_true of term
  24. | Ite_false of term
  25. | LRA of clause
  26. | Composite of {
    1. assumptions : (string * Lit.t) list;
    2. steps : composite_step array;
    }
and bool_c_name = string
and composite_step =
  1. | S_step_c of {
    1. name : string;
    2. res : clause;
    3. proof : t;
    }
    (*

    A named step in Composite, with the expected result. This decouples the checking of the sub-proof, from its use in the rest of the proof, as we can use res even if checking proof failed.

    *)
  2. | S_step_anon of {
    1. name : string;
    2. proof : t;
    }
    (*

    A named intermediate proof, to be reused in subsequent proofs. Unlike S_step_c we do not specify the expected result so if this fails, any proof downstream will also fail.

    *)
  3. | S_define_t of term * term
  4. | S_define_t_name of string * term
and hres_step =
  1. | R of {
    1. pivot : term;
    2. p : t;
    }
  2. | R1 of t
  3. | P of {
    1. lhs : term;
    2. rhs : term;
    3. p : t;
    }
  4. | P1 of t
val r : t -> pivot:term -> hres_step
val r1 : t -> hres_step
val p : t -> lhs:term -> rhs:term -> hres_step
val p1 : t -> hres_step
val stepc : name:string -> clause -> t -> composite_step
val step_anon : name:string -> t -> composite_step
val deft : term -> term -> composite_step
val deft_name : string -> term -> composite_step
val is_trivial_refl : t -> bool
val default : t
val sorry_c : Lit.t Iter.t -> t
val sorry_c_l : clause -> t
val sorry : t
val refl : term -> t
val ref_by_name : string -> t
val cc_lemma : clause -> t
val cc_imply_l : t list -> term -> term -> t
val cc_imply2 : t -> t -> term -> term -> t
val assertion : term -> t
val assertion_c : Lit.t Iter.t -> t
val assertion_c_l : clause -> t
val rup : clause -> t list -> t
val clause_rw : t -> res:clause -> using:t list -> t
val composite_a : ?assms:(string * Lit.t) list -> composite_step array -> t
val composite_l : ?assms:(string * Lit.t) list -> composite_step list -> t
val composite_iter : ?assms:(string * Lit.t) list -> composite_step Iter.t -> t
val isa_split : ty -> term Iter.t -> t
val isa_disj : ty -> term -> term -> t
val cstor_inj : Cstor.t -> int -> term list -> term list -> t
val ite_true : term -> t
val ite_false : term -> t
val true_is_true : t
val true_neq_false : t
val bool_eq : term -> term -> t
val bool_c : bool_c_name -> term list -> t
val hres_l : t -> hres_step list -> t
val hres_iter : t -> hres_step Iter.t -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val paramod1 : t -> t -> t
val lra_l : clause -> t
val lra : Lit.t Iter.t -> t
diff --git a/dev/sidekick/Sidekick_quip/index.html b/dev/sidekick/Sidekick_quip/index.html index 87d484dd..f12a0864 100644 --- a/dev/sidekick/Sidekick_quip/index.html +++ b/dev/sidekick/Sidekick_quip/index.html @@ -1,2 +1,2 @@ -Sidekick_quip (sidekick.Sidekick_quip)

Module Sidekick_quip

Proofs of unsatisfiability in the Quip proof format..

This targets Quip as an experimental proof backend.

module Proof : sig ... end
type t = Proof.t

The state holding the whole proof.

type out_format =
  1. | Sexp
    (*

    S-expressions

    *)
  2. | CSexp
    (*

    Canonical S-expressions

    *)

What format to use to serialize the proof?

val pp_out_format : out_format Sidekick_util.Fmt.printer
val output : ?fmt:out_format -> Stdlib.out_channel -> t -> unit
val pp_debug : t Sidekick_util.Fmt.printer
\ No newline at end of file +Sidekick_quip (sidekick.Sidekick_quip)

Module Sidekick_quip

Proofs of unsatisfiability in the Quip proof format..

This targets Quip as an experimental proof backend.

module Proof : sig ... end
type t = Proof.t

The state holding the whole proof.

type out_format =
  1. | Sexp
    (*

    S-expressions

    *)
  2. | CSexp
    (*

    Canonical S-expressions

    *)

What format to use to serialize the proof?

val pp_out_format : out_format Sidekick_util.Fmt.printer
val output : ?fmt:out_format -> Stdlib.out_channel -> t -> unit
val pp_debug : t Sidekick_util.Fmt.printer
diff --git a/dev/sidekick/Sidekick_sat/.dummy b/dev/sidekick/Sidekick_sat/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_sat/Solver/Clause/index.html b/dev/sidekick/Sidekick_sat/Solver/Clause/index.html index 7e7ea981..9a9408ef 100644 --- a/dev/sidekick/Sidekick_sat/Solver/Clause/index.html +++ b/dev/sidekick/Sidekick_sat/Solver/Clause/index.html @@ -1,2 +1,2 @@ -Clause (sidekick.Sidekick_sat.Solver.Clause)

Module Solver.Clause

type t = clause
val equal : t -> t -> bool
module Tbl : Stdlib.Hashtbl.S with type key = t
val pp : store -> t Sidekick_core.Fmt.printer

Print the clause

val short_name : store -> t -> string

Short name for a clause. Unspecified

val n_atoms : store -> t -> int
val lits_iter : store -> t -> Sidekick_core.Lit.t Iter.t

Literals of a clause

val lits_a : store -> t -> Sidekick_core.Lit.t array

Atoms of a clause

val lits_l : store -> t -> Sidekick_core.Lit.t list

List of atoms of a clause

\ No newline at end of file +Clause (sidekick.Sidekick_sat.Solver.Clause)

Module Solver.Clause

type t = clause
val equal : t -> t -> bool
module Tbl : Stdlib.Hashtbl.S with type key = t
val pp : store -> t Sidekick_core.Fmt.printer

Print the clause

val short_name : store -> t -> string

Short name for a clause. Unspecified

val n_atoms : store -> t -> int
val lits_iter : store -> t -> Sidekick_core.Lit.t Iter.t

Literals of a clause

val lits_a : store -> t -> Sidekick_core.Lit.t array

Atoms of a clause

val lits_l : store -> t -> Sidekick_core.Lit.t list

List of atoms of a clause

diff --git a/dev/sidekick/Sidekick_sat/Solver/index.html b/dev/sidekick/Sidekick_sat/Solver/index.html index 6dafc0b0..397416db 100644 --- a/dev/sidekick/Sidekick_sat/Solver/index.html +++ b/dev/sidekick/Sidekick_sat/Solver/index.html @@ -1,5 +1,5 @@ -Solver (sidekick.Sidekick_sat.Solver)

Module Sidekick_sat.Solver

The external interface implemented by SAT solvers.

type clause
type plugin = (module Sidekick_sat__.Sigs.PLUGIN)
type solver

The main solver type.

type store

Stores atoms, clauses, etc.

module Clause : sig ... end

Main Solver Type

type t = solver

Main solver type, containing all state for solving.

val store : t -> store

Store for the solver

val stat : t -> Sidekick_util.Stat.t

Statistics

val tracer : t -> Tracer.t

Access the inner proof

val on_conflict : t -> (Clause.t, unit) Sidekick_util.Event.t
val on_decision : t -> (Sidekick_core.Lit.t, unit) Sidekick_util.Event.t
val on_learnt : t -> (Clause.t, unit) Sidekick_util.Event.t
val on_gc : t -> (Sidekick_core.Lit.t array, unit) Sidekick_util.Event.t

Types

type res =
  1. | Sat of (module Sidekick_sat__.Sigs.SAT_STATE)
    (*

    Returned when the solver reaches SAT, with a model

    *)
  2. | Unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)
    (*

    Returned when the solver reaches UNSAT, with a proof

    *)

Result type for the solver

exception UndecidedLit

Exception raised by the evaluating functions when a literal has not yet been assigned a value.

Base operations

val assume : t -> Sidekick_core.Lit.t list list -> unit

Add the list of clauses to the current set of assumptions. Modifies the sat solver state in place.

val add_clause : +Solver (sidekick.Sidekick_sat.Solver)

Module Sidekick_sat.Solver

The external interface implemented by SAT solvers.

type clause
type plugin = (module Sidekick_sat__.Sigs.PLUGIN)
type solver

The main solver type.

type store

Stores atoms, clauses, etc.

module Clause : sig ... end

Main Solver Type

type t = solver

Main solver type, containing all state for solving.

val store : t -> store

Store for the solver

val stat : t -> Sidekick_util.Stat.t

Statistics

val tracer : t -> Tracer.t

Access the inner proof

val on_conflict : t -> (Clause.t, unit) Sidekick_util.Event.t
val on_decision : t -> (Sidekick_core.Lit.t, unit) Sidekick_util.Event.t
val on_learnt : t -> (Clause.t, unit) Sidekick_util.Event.t
val on_gc : t -> (Sidekick_core.Lit.t array, unit) Sidekick_util.Event.t

Types

type res =
  1. | Sat of (module Sidekick_sat__.Sigs.SAT_STATE)
    (*

    Returned when the solver reaches SAT, with a model

    *)
  2. | Unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)
    (*

    Returned when the solver reaches UNSAT, with a proof

    *)

Result type for the solver

exception UndecidedLit

Exception raised by the evaluating functions when a literal has not yet been assigned a value.

Base operations

val assume : t -> Sidekick_core.Lit.t list list -> unit

Add the list of clauses to the current set of assumptions. Modifies the sat solver state in place.

val add_clause : t -> Sidekick_core.Lit.t list -> Sidekick_proof.Pterm.delayed -> @@ -8,28 +8,28 @@ Sidekick_core.Lit.t array -> Sidekick_proof.Pterm.delayed -> unit

Lower level addition of clauses

val add_input_clause : t -> Sidekick_core.Lit.t list -> unit

Like add_clause but with the justification of being an input clause

val add_input_clause_a : t -> Sidekick_core.Lit.t array -> unit

Like add_clause_a but with justification of being an input clause

Solving

val solve : - ?on_progress:(unit -> unit) -> - ?assumptions:Sidekick_core.Lit.t list -> + ?on_progress:(unit -> unit) -> + ?assumptions:Sidekick_core.Lit.t list -> t -> - res

Try and solves the current set of clauses.

  • parameter assumptions

    additional atomic assumptions to be temporarily added. The assumptions are just used for this call to solve, they are not saved in the solver's state.

  • parameter on_progress

    regularly called during solving. Can raise Resource_exhausted to stop solving.

  • raises Resource_exhausted

    if the on_progress handler raised it to stop

Evaluating and adding literals

val add_lit : t -> ?default_pol:bool -> Sidekick_core.Lit.t -> unit

Ensure the SAT solver handles this particular literal, ie add a boolean variable for it if it's not already there.

val set_default_pol : t -> Sidekick_core.Lit.t -> bool -> unit

Set default polarity for the given boolean variable. Sign of the literal is ignored.

val true_at_level0 : t -> Sidekick_core.Lit.t -> bool

true_at_level0 a returns true if a was proved at level0, i.e. it must hold in all models

val eval_lit : t -> Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.lbool

Evaluate atom in current state

Assumption stack

val push_assumption : t -> Sidekick_core.Lit.t -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions.

type propagation_result =
  1. | PR_sat
  2. | PR_conflict of {
    1. backtracked : int;
    }
  3. | PR_unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)

Result returned by check_sat_propagations_only

val check_sat_propagations_only : - ?assumptions:Sidekick_core.Lit.t list -> + res

Try and solves the current set of clauses.

  • parameter assumptions

    additional atomic assumptions to be temporarily added. The assumptions are just used for this call to solve, they are not saved in the solver's state.

  • parameter on_progress

    regularly called during solving. Can raise Resource_exhausted to stop solving.

  • raises Resource_exhausted

    if the on_progress handler raised it to stop

Evaluating and adding literals

val add_lit : t -> ?default_pol:bool -> Sidekick_core.Lit.t -> unit

Ensure the SAT solver handles this particular literal, ie add a boolean variable for it if it's not already there.

val set_default_pol : t -> Sidekick_core.Lit.t -> bool -> unit

Set default polarity for the given boolean variable. Sign of the literal is ignored.

val true_at_level0 : t -> Sidekick_core.Lit.t -> bool

true_at_level0 a returns true if a was proved at level0, i.e. it must hold in all models

val eval_lit : t -> Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.lbool

Evaluate atom in current state

Assumption stack

val push_assumption : t -> Sidekick_core.Lit.t -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions.

type propagation_result =
  1. | PR_sat
  2. | PR_conflict of {
    1. backtracked : int;
    }
  3. | PR_unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)

Result returned by check_sat_propagations_only

val check_sat_propagations_only : + ?assumptions:Sidekick_core.Lit.t list -> t -> propagation_result

check_sat_propagations_only solver uses the added clauses and local assumptions (using push_assumptions and assumptions) to quickly assess whether the context is satisfiable. It is not complete; calling solve is required to get an accurate result.

  • returns

    either Ok() if propagation yielded no conflict, or Error c if a conflict clause c was found.

Initialization

val plugin_cdcl_t : (module Sidekick_sat__.Sigs.THEORY_CDCL_T) -> (module Sidekick_sat__.Sigs.PLUGIN)
val mk_plugin_cdcl_t : - push_level:(unit -> unit) -> - pop_levels:(int -> unit) -> - ?partial_check:((module Sidekick_sat__.Sigs.ACTS) -> unit) -> - final_check:((module Sidekick_sat__.Sigs.ACTS) -> unit) -> + push_level:(unit -> unit) -> + pop_levels:(int -> unit) -> + ?partial_check:((module Sidekick_sat__.Sigs.ACTS) -> unit) -> + final_check:((module Sidekick_sat__.Sigs.ACTS) -> unit) -> unit -> (module Sidekick_sat__.Sigs.PLUGIN)

Create a plugin

  • parameter push_level

    create a new backtrack level

  • parameter pop_levels

    Pop n levels of the plugin

  • parameter partial_check

    Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.

  • parameter final_check

    Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.

val create : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Tiny | `Small | `Big ] -> - tracer:Tracer.t -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Tiny | `Small | `Big ] -> + tracer:Tracer.t -> plugin -> t

Create new solver

  • parameter theory

    the theory

  • parameter the

    proof

  • parameter size

    the initial size of internal data structures. The bigger, the faster, but also the more RAM it uses.

val plugin_pure_sat : plugin
val create_pure_sat : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Tiny | `Small | `Big ] -> - tracer:Tracer.t -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Tiny | `Small | `Big ] -> + tracer:Tracer.t -> unit -> - t
\ No newline at end of file + t
diff --git a/dev/sidekick/Sidekick_sat/Tracer/class-dummy/index.html b/dev/sidekick/Sidekick_sat/Tracer/class-dummy/index.html index 57aa9b8f..b7ca0cc0 100644 --- a/dev/sidekick/Sidekick_sat/Tracer/class-dummy/index.html +++ b/dev/sidekick/Sidekick_sat/Tracer/class-dummy/index.html @@ -1,5 +1,5 @@ -dummy (sidekick.Sidekick_sat.Tracer.dummy)

Class Tracer.dummy

inherit Proof.Tracer.t
method sat_assert_clause : id:int -> +dummy (sidekick.Sidekick_sat.Tracer.dummy)

Class Tracer.dummy

inherit Proof.Tracer.t
method sat_assert_clause : id:int -> Sidekick_core.Lit.t Iter.t -> Proof.Step.id -> - Tr.Entry_id.t
method sat_delete_clause : id:int -> Sidekick_core.Lit.t Iter.t -> unit
method sat_unsat_clause : id:int -> Tr.Entry_id.t
\ No newline at end of file + Tr.Entry_id.t
method sat_delete_clause : id:int -> Sidekick_core.Lit.t Iter.t -> unit
method sat_unsat_clause : id:int -> Tr.Entry_id.t
diff --git a/dev/sidekick/Sidekick_sat/Tracer/class-type-t/index.html b/dev/sidekick/Sidekick_sat/Tracer/class-type-t/index.html index 14cbd89c..205e3e1f 100644 --- a/dev/sidekick/Sidekick_sat/Tracer/class-type-t/index.html +++ b/dev/sidekick/Sidekick_sat/Tracer/class-type-t/index.html @@ -1,5 +1,5 @@ -t (sidekick.Sidekick_sat.Tracer.t)

Class type Tracer.t

Tracer for the SAT solver.

inherit Proof.Tracer.t
method sat_assert_clause : id:int -> +t (sidekick.Sidekick_sat.Tracer.t)

Class type Tracer.t

Tracer for the SAT solver.

inherit Proof.Tracer.t
method sat_assert_clause : id:int -> Sidekick_core.Lit.t Iter.t -> Proof.Step.id -> - Tr.Entry_id.t
method sat_delete_clause : id:int -> Sidekick_core.Lit.t Iter.t -> unit
method sat_unsat_clause : id:int -> Tr.Entry_id.t
\ No newline at end of file + Tr.Entry_id.t
method sat_delete_clause : id:int -> Sidekick_core.Lit.t Iter.t -> unit
method sat_unsat_clause : id:int -> Tr.Entry_id.t
diff --git a/dev/sidekick/Sidekick_sat/Tracer/index.html b/dev/sidekick/Sidekick_sat/Tracer/index.html index 5dbf10da..e2617bd3 100644 --- a/dev/sidekick/Sidekick_sat/Tracer/index.html +++ b/dev/sidekick/Sidekick_sat/Tracer/index.html @@ -1,12 +1,12 @@ -Tracer (sidekick.Sidekick_sat.Tracer)

Module Sidekick_sat.Tracer

Tracer for clauses and literals

module Tr = Sidekick_trace
module Proof = Sidekick_proof
class type t = object ... end

Tracer for the SAT solver.

class dummy : t
val dummy : t

Dummy tracer, recording nothing.

val assert_clause : +Tracer (sidekick.Sidekick_sat.Tracer)

Module Sidekick_sat.Tracer

Tracer for clauses and literals

module Tr = Sidekick_trace
module Proof = Sidekick_proof
class type t = object ... end

Tracer for the SAT solver.

class dummy : t
val dummy : t

Dummy tracer, recording nothing.

val assert_clause : t -> - id:int -> + id:int -> Sidekick_core.Lit.t Iter.t -> Proof.Step.id -> Tr.Entry_id.t
val assert_clause' : t -> - id:int -> + id:int -> Sidekick_core.Lit.t Iter.t -> Proof.Step.id -> - unit
val delete_clause : t -> id:int -> Sidekick_core.Lit.t Iter.t -> unit
val unsat_clause : t -> id:int -> Tr.Entry_id.t
val unsat_clause' : t -> id:int -> unit
\ No newline at end of file + unit
val delete_clause : t -> id:int -> Sidekick_core.Lit.t Iter.t -> unit
val unsat_clause : t -> id:int -> Tr.Entry_id.t
val unsat_clause' : t -> id:int -> unit
diff --git a/dev/sidekick/Sidekick_sat/index.html b/dev/sidekick/Sidekick_sat/index.html index 93d6461c..22a61129 100644 --- a/dev/sidekick/Sidekick_sat/index.html +++ b/dev/sidekick/Sidekick_sat/index.html @@ -1,5 +1,5 @@ -Sidekick_sat (sidekick.Sidekick_sat)

Module Sidekick_sat

Main API

module Proof = Sidekick_proof
exception UndecidedLit
module type SAT_STATE = sig ... end

Solver in a "SATISFIABLE" state

type sat_state = (module SAT_STATE)

The type of values returned when the solver reaches a SAT state.

module type UNSAT_STATE = sig ... end

Solver in an "UNSATISFIABLE" state

type 'clause unsat_state = (module UNSAT_STATE with type clause = 'clause)

The type of values returned when the solver reaches an UNSAT state.

type same_sign = bool

This type is used during the normalisation of lits. true means the literal stayed the same, false that its sign was flipped.

type reason =
  1. | Consequence of unit -> Sidekick_core.Lit.t list * Sidekick_proof.Pterm.delayed

The type of reasons for propagations of a lit f.

Consequence (l, p) means that the lits in l imply the propagated lit f. The proof should be a proof of the clause "l implies f".

invariant: in Consequence (fun () -> l,p), all elements of l must be true in the current trail.

note on lazyiness: the justification is suspended (using unit -> …) to avoid potentially costly computations that might never be used if this literal is backtracked without participating in a conflict. Therefore the function that produces (l,p) needs only be safe in trails (partial models) that are conservative extensions of the current trail. If the theory isn't robust w.r.t. extensions of the trail (e.g. if its internal state undergoes significant changes), it can be easier to produce the explanation eagerly when propagating, and then use Consequence (fun () -> expl, proof) with the already produced (expl,proof) tuple.

type lbool =
  1. | L_true
  2. | L_false
  3. | L_undefined
    (*

    Valuation of an atom

    *)
val pp_lbool : Sidekick_core.Fmt.t -> lbool -> unit
module type ACTS = sig ... end

Actions available to the Plugin.

type acts = (module ACTS)

The type for a slice of assertions to assume/propagate in the theory.

module type THEORY_CDCL_T = sig ... end

Signature for theories to be given to the CDCL(T) solver

module type PLUGIN = sig ... end
module Solver : sig ... end

The external interface implemented by SAT solvers.

module Tracer : sig ... end

Tracer for clauses and literals

include module type of struct include Solver end
type clause = Solver.clause
type plugin = (module Sidekick_sat__.Sigs.PLUGIN)
type solver = Solver.solver

The main solver type.

type store = Solver.store

Stores atoms, clauses, etc.

module Clause = Solver.Clause

Main Solver Type

type t = solver

Main solver type, containing all state for solving.

val store : t -> store

Store for the solver

val stat : t -> Sidekick_util.Stat.t

Statistics

val tracer : t -> Tracer.t

Access the inner proof

val on_conflict : t -> (Clause.t, unit) Sidekick_util.Event.t
val on_decision : t -> (Sidekick_core.Lit.t, unit) Sidekick_util.Event.t
val on_learnt : t -> (Clause.t, unit) Sidekick_util.Event.t
val on_gc : t -> (Sidekick_core.Lit.t array, unit) Sidekick_util.Event.t

Types

type res = Solver.res =
  1. | Sat of (module Sidekick_sat__.Sigs.SAT_STATE)
    (*

    Returned when the solver reaches SAT, with a model

    *)
  2. | Unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)
    (*

    Returned when the solver reaches UNSAT, with a proof

    *)

Result type for the solver

exception UndecidedLit

Exception raised by the evaluating functions when a literal has not yet been assigned a value.

Base operations

val assume : t -> Sidekick_core.Lit.t list list -> unit

Add the list of clauses to the current set of assumptions. Modifies the sat solver state in place.

val add_clause : +Sidekick_sat (sidekick.Sidekick_sat)

Module Sidekick_sat

Main API

module Proof = Sidekick_proof
exception UndecidedLit
module type SAT_STATE = sig ... end

Solver in a "SATISFIABLE" state

type sat_state = (module SAT_STATE)

The type of values returned when the solver reaches a SAT state.

module type UNSAT_STATE = sig ... end

Solver in an "UNSATISFIABLE" state

type 'clause unsat_state = (module UNSAT_STATE with type clause = 'clause)

The type of values returned when the solver reaches an UNSAT state.

type same_sign = bool

This type is used during the normalisation of lits. true means the literal stayed the same, false that its sign was flipped.

type reason =
  1. | Consequence of unit -> Sidekick_core.Lit.t list * Sidekick_proof.Pterm.delayed

The type of reasons for propagations of a lit f.

Consequence (l, p) means that the lits in l imply the propagated lit f. The proof should be a proof of the clause "l implies f".

invariant: in Consequence (fun () -> l,p), all elements of l must be true in the current trail.

note on lazyiness: the justification is suspended (using unit -> …) to avoid potentially costly computations that might never be used if this literal is backtracked without participating in a conflict. Therefore the function that produces (l,p) needs only be safe in trails (partial models) that are conservative extensions of the current trail. If the theory isn't robust w.r.t. extensions of the trail (e.g. if its internal state undergoes significant changes), it can be easier to produce the explanation eagerly when propagating, and then use Consequence (fun () -> expl, proof) with the already produced (expl,proof) tuple.

type lbool =
  1. | L_true
  2. | L_false
  3. | L_undefined
    (*

    Valuation of an atom

    *)
val pp_lbool : Sidekick_core.Fmt.t -> lbool -> unit
module type ACTS = sig ... end

Actions available to the Plugin.

type acts = (module ACTS)

The type for a slice of assertions to assume/propagate in the theory.

module type THEORY_CDCL_T = sig ... end

Signature for theories to be given to the CDCL(T) solver

module type PLUGIN = sig ... end
module Solver : sig ... end

The external interface implemented by SAT solvers.

module Tracer : sig ... end

Tracer for clauses and literals

include module type of struct include Solver end
type clause = Solver.clause
type plugin = (module Sidekick_sat__.Sigs.PLUGIN)
type solver = Solver.solver

The main solver type.

type store = Solver.store

Stores atoms, clauses, etc.

module Clause = Solver.Clause

Main Solver Type

type t = solver

Main solver type, containing all state for solving.

val store : t -> store

Store for the solver

val stat : t -> Sidekick_util.Stat.t

Statistics

val tracer : t -> Tracer.t

Access the inner proof

val on_conflict : t -> (Clause.t, unit) Sidekick_util.Event.t
val on_decision : t -> (Sidekick_core.Lit.t, unit) Sidekick_util.Event.t
val on_learnt : t -> (Clause.t, unit) Sidekick_util.Event.t
val on_gc : t -> (Sidekick_core.Lit.t array, unit) Sidekick_util.Event.t

Types

type res = Solver.res =
  1. | Sat of (module Sidekick_sat__.Sigs.SAT_STATE)
    (*

    Returned when the solver reaches SAT, with a model

    *)
  2. | Unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)
    (*

    Returned when the solver reaches UNSAT, with a proof

    *)

Result type for the solver

exception UndecidedLit

Exception raised by the evaluating functions when a literal has not yet been assigned a value.

Base operations

val assume : t -> Sidekick_core.Lit.t list list -> unit

Add the list of clauses to the current set of assumptions. Modifies the sat solver state in place.

val add_clause : t -> Sidekick_core.Lit.t list -> Sidekick_proof.Pterm.delayed -> @@ -7,29 +7,29 @@ t -> Sidekick_core.Lit.t array -> Sidekick_proof.Pterm.delayed -> - unit

Lower level addition of clauses

val add_input_clause : t -> Sidekick_core.Lit.t list -> unit

Like add_clause but with the justification of being an input clause

val add_input_clause_a : t -> Sidekick_core.Lit.t array -> unit

Like add_clause_a but with justification of being an input clause

Solving

val solve : - ?on_progress:(unit -> unit) -> - ?assumptions:Sidekick_core.Lit.t list -> + unit

Lower level addition of clauses

val add_input_clause : t -> Sidekick_core.Lit.t list -> unit

Like add_clause but with the justification of being an input clause

val add_input_clause_a : t -> Sidekick_core.Lit.t array -> unit

Like add_clause_a but with justification of being an input clause

Solving

val solve : + ?on_progress:(unit -> unit) -> + ?assumptions:Sidekick_core.Lit.t list -> t -> - res

Try and solves the current set of clauses.

  • parameter assumptions

    additional atomic assumptions to be temporarily added. The assumptions are just used for this call to solve, they are not saved in the solver's state.

  • parameter on_progress

    regularly called during solving. Can raise Resource_exhausted to stop solving.

  • raises Resource_exhausted

    if the on_progress handler raised it to stop

Evaluating and adding literals

val add_lit : t -> ?default_pol:bool -> Sidekick_core.Lit.t -> unit

Ensure the SAT solver handles this particular literal, ie add a boolean variable for it if it's not already there.

val set_default_pol : t -> Sidekick_core.Lit.t -> bool -> unit

Set default polarity for the given boolean variable. Sign of the literal is ignored.

val true_at_level0 : t -> Sidekick_core.Lit.t -> bool

true_at_level0 a returns true if a was proved at level0, i.e. it must hold in all models

val eval_lit : t -> Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.lbool

Evaluate atom in current state

Assumption stack

val push_assumption : t -> Sidekick_core.Lit.t -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions.

type propagation_result = Solver.propagation_result =
  1. | PR_sat
  2. | PR_conflict of {
    1. backtracked : int;
    }
  3. | PR_unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)

Result returned by check_sat_propagations_only

val check_sat_propagations_only : - ?assumptions:Sidekick_core.Lit.t list -> + res

Try and solves the current set of clauses.

  • parameter assumptions

    additional atomic assumptions to be temporarily added. The assumptions are just used for this call to solve, they are not saved in the solver's state.

  • parameter on_progress

    regularly called during solving. Can raise Resource_exhausted to stop solving.

  • raises Resource_exhausted

    if the on_progress handler raised it to stop

Evaluating and adding literals

val add_lit : t -> ?default_pol:bool -> Sidekick_core.Lit.t -> unit

Ensure the SAT solver handles this particular literal, ie add a boolean variable for it if it's not already there.

val set_default_pol : t -> Sidekick_core.Lit.t -> bool -> unit

Set default polarity for the given boolean variable. Sign of the literal is ignored.

val true_at_level0 : t -> Sidekick_core.Lit.t -> bool

true_at_level0 a returns true if a was proved at level0, i.e. it must hold in all models

val eval_lit : t -> Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.lbool

Evaluate atom in current state

Assumption stack

val push_assumption : t -> Sidekick_core.Lit.t -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions.

type propagation_result = Solver.propagation_result =
  1. | PR_sat
  2. | PR_conflict of {
    1. backtracked : int;
    }
  3. | PR_unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)

Result returned by check_sat_propagations_only

val check_sat_propagations_only : + ?assumptions:Sidekick_core.Lit.t list -> t -> - propagation_result

check_sat_propagations_only solver uses the added clauses and local assumptions (using push_assumptions and assumptions) to quickly assess whether the context is satisfiable. It is not complete; calling solve is required to get an accurate result.

  • returns

    either Ok() if propagation yielded no conflict, or Error c if a conflict clause c was found.

Initialization

val plugin_cdcl_t : + propagation_result

check_sat_propagations_only solver uses the added clauses and local assumptions (using push_assumptions and assumptions) to quickly assess whether the context is satisfiable. It is not complete; calling solve is required to get an accurate result.

  • returns

    either Ok() if propagation yielded no conflict, or Error c if a conflict clause c was found.

Initialization

val plugin_cdcl_t : (module Sidekick_sat__.Sigs.THEORY_CDCL_T) -> (module Sidekick_sat__.Sigs.PLUGIN)
val mk_plugin_cdcl_t : - push_level:(unit -> unit) -> - pop_levels:(int -> unit) -> - ?partial_check:((module Sidekick_sat__.Sigs.ACTS) -> unit) -> - final_check:((module Sidekick_sat__.Sigs.ACTS) -> unit) -> + push_level:(unit -> unit) -> + pop_levels:(int -> unit) -> + ?partial_check:((module Sidekick_sat__.Sigs.ACTS) -> unit) -> + final_check:((module Sidekick_sat__.Sigs.ACTS) -> unit) -> unit -> (module Sidekick_sat__.Sigs.PLUGIN)

Create a plugin

  • parameter push_level

    create a new backtrack level

  • parameter pop_levels

    Pop n levels of the plugin

  • parameter partial_check

    Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.

  • parameter final_check

    Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.

val create : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Tiny | `Small | `Big ] -> - tracer:Tracer.t -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Tiny | `Small | `Big ] -> + tracer:Tracer.t -> plugin -> t

Create new solver

  • parameter theory

    the theory

  • parameter the

    proof

  • parameter size

    the initial size of internal data structures. The bigger, the faster, but also the more RAM it uses.

val plugin_pure_sat : plugin
val create_pure_sat : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Tiny | `Small | `Big ] -> - tracer:Tracer.t -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Tiny | `Small | `Big ] -> + tracer:Tracer.t -> unit -> - t
\ No newline at end of file + t
diff --git a/dev/sidekick/Sidekick_sat/module-type-ACTS/index.html b/dev/sidekick/Sidekick_sat/module-type-ACTS/index.html index 61f8144e..3d2829cc 100644 --- a/dev/sidekick/Sidekick_sat/module-type-ACTS/index.html +++ b/dev/sidekick/Sidekick_sat/module-type-ACTS/index.html @@ -1,9 +1,9 @@ -ACTS (sidekick.Sidekick_sat.ACTS)

Module type Sidekick_sat.ACTS

Actions available to the Plugin.

The plugin provides callbacks for the SAT solver to use. These callbacks are provided with a (module ACTS) so they can modify the SAT solver by adding new lemmas, raise conflicts, etc.

val proof_tracer : Sidekick_proof.Tracer.t
val iter_assumptions : (Sidekick_core.Lit.t -> unit) -> unit

Traverse the new assumptions on the boolean trail.

val eval_lit : Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.lbool

Obtain current value of the given literal

val add_lit : ?default_pol:bool -> Sidekick_core.Lit.t -> unit

Map the given lit to an internal atom, which will be decided by the SAT solver.

val add_clause : - ?keep:bool -> +ACTS (sidekick.Sidekick_sat.ACTS)

Module type Sidekick_sat.ACTS

Actions available to the Plugin.

The plugin provides callbacks for the SAT solver to use. These callbacks are provided with a (module ACTS) so they can modify the SAT solver by adding new lemmas, raise conflicts, etc.

val proof_tracer : Sidekick_proof.Tracer.t
val iter_assumptions : (Sidekick_core.Lit.t -> unit) -> unit

Traverse the new assumptions on the boolean trail.

val eval_lit : Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.lbool

Obtain current value of the given literal

val add_lit : ?default_pol:bool -> Sidekick_core.Lit.t -> unit

Map the given lit to an internal atom, which will be decided by the SAT solver.

val add_clause : + ?keep:bool -> Sidekick_core.Lit.t list -> Sidekick_proof.Pterm.delayed -> unit

Add a clause to the solver.

  • parameter keep

    if true, the clause will be kept by the solver. Otherwise the solver is allowed to GC the clause and propose this partial model again.

    • C_use_allocator alloc puts the clause in the given allocator.
val raise_conflict : Sidekick_core.Lit.t list -> Sidekick_proof.Pterm.delayed -> - 'b

Raise a conflict, yielding control back to the solver. The list of atoms must be a valid theory lemma that is false in the current trail.

val propagate : Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.reason -> unit

Propagate a lit, i.e. the theory can evaluate the lit to be true (see the definition of eval_res

val add_decision_lit : Sidekick_core.Lit.t -> bool -> unit

Ask the SAT solver to decide on the given lit with given sign before it can answer SAT. The order of decisions is still unspecified. Useful for theory combination. This will be undone on backtracking.

\ No newline at end of file + 'b

Raise a conflict, yielding control back to the solver. The list of atoms must be a valid theory lemma that is false in the current trail.

val propagate : Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.reason -> unit

Propagate a lit, i.e. the theory can evaluate the lit to be true (see the definition of eval_res

val add_decision_lit : Sidekick_core.Lit.t -> bool -> unit

Ask the SAT solver to decide on the given lit with given sign before it can answer SAT. The order of decisions is still unspecified. Useful for theory combination. This will be undone on backtracking.

diff --git a/dev/sidekick/Sidekick_sat/module-type-PLUGIN/index.html b/dev/sidekick/Sidekick_sat/module-type-PLUGIN/index.html index 7387f11a..91a048a6 100644 --- a/dev/sidekick/Sidekick_sat/module-type-PLUGIN/index.html +++ b/dev/sidekick/Sidekick_sat/module-type-PLUGIN/index.html @@ -1,2 +1,2 @@ -PLUGIN (sidekick.Sidekick_sat.PLUGIN)

Module type Sidekick_sat.PLUGIN

val push_level : unit -> unit

Create a new backtrack level

val pop_levels : int -> unit

Pop n levels of the theory

val partial_check : (module Sidekick_sat__.Sigs.ACTS) -> unit

Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.

val final_check : (module Sidekick_sat__.Sigs.ACTS) -> unit

Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.

val has_theory : bool

true iff the solver is parametrized by a theory, not just pure SAT.

\ No newline at end of file +PLUGIN (sidekick.Sidekick_sat.PLUGIN)

Module type Sidekick_sat.PLUGIN

val push_level : unit -> unit

Create a new backtrack level

val pop_levels : int -> unit

Pop n levels of the theory

val partial_check : (module Sidekick_sat__.Sigs.ACTS) -> unit

Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.

val final_check : (module Sidekick_sat__.Sigs.ACTS) -> unit

Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.

val has_theory : bool

true iff the solver is parametrized by a theory, not just pure SAT.

diff --git a/dev/sidekick/Sidekick_sat/module-type-SAT_STATE/index.html b/dev/sidekick/Sidekick_sat/module-type-SAT_STATE/index.html index 83d76e91..f07efa62 100644 --- a/dev/sidekick/Sidekick_sat/module-type-SAT_STATE/index.html +++ b/dev/sidekick/Sidekick_sat/module-type-SAT_STATE/index.html @@ -1,2 +1,2 @@ -SAT_STATE (sidekick.Sidekick_sat.SAT_STATE)

Module type Sidekick_sat.SAT_STATE

Solver in a "SATISFIABLE" state

val eval : Sidekick_core.Lit.t -> bool

Returns the valuation of a lit in the current state of the sat solver.

  • raises UndecidedLit

    if the literal is not decided

val eval_level : Sidekick_core.Lit.t -> bool * int

Return the current assignement of the literals, as well as its decision level. If the level is 0, then it is necessary for the literal to have this value; otherwise it is due to choices that can potentially be backtracked.

  • raises UndecidedLit

    if the literal is not decided

val iter_trail : (Sidekick_core.Lit.t -> unit) -> unit

Iter through the lits in order of decision/propagation (starting from the first propagation, to the last propagation).

\ No newline at end of file +SAT_STATE (sidekick.Sidekick_sat.SAT_STATE)

Module type Sidekick_sat.SAT_STATE

Solver in a "SATISFIABLE" state

val eval : Sidekick_core.Lit.t -> bool

Returns the valuation of a lit in the current state of the sat solver.

val eval_level : Sidekick_core.Lit.t -> bool * int

Return the current assignement of the literals, as well as its decision level. If the level is 0, then it is necessary for the literal to have this value; otherwise it is due to choices that can potentially be backtracked.

val iter_trail : (Sidekick_core.Lit.t -> unit) -> unit

Iter through the lits in order of decision/propagation (starting from the first propagation, to the last propagation).

diff --git a/dev/sidekick/Sidekick_sat/module-type-THEORY_CDCL_T/index.html b/dev/sidekick/Sidekick_sat/module-type-THEORY_CDCL_T/index.html index 4a7e21dc..d5167d50 100644 --- a/dev/sidekick/Sidekick_sat/module-type-THEORY_CDCL_T/index.html +++ b/dev/sidekick/Sidekick_sat/module-type-THEORY_CDCL_T/index.html @@ -1,2 +1,2 @@ -THEORY_CDCL_T (sidekick.Sidekick_sat.THEORY_CDCL_T)

Module type Sidekick_sat.THEORY_CDCL_T

Signature for theories to be given to the CDCL(T) solver

val push_level : unit -> unit

Create a new backtrack level

val pop_levels : int -> unit

Pop n levels of the theory

val partial_check : (module Sidekick_sat__.Sigs.ACTS) -> unit

Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.

val final_check : (module Sidekick_sat__.Sigs.ACTS) -> unit

Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.

\ No newline at end of file +THEORY_CDCL_T (sidekick.Sidekick_sat.THEORY_CDCL_T)

Module type Sidekick_sat.THEORY_CDCL_T

Signature for theories to be given to the CDCL(T) solver

val push_level : unit -> unit

Create a new backtrack level

val pop_levels : int -> unit

Pop n levels of the theory

val partial_check : (module Sidekick_sat__.Sigs.ACTS) -> unit

Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.

val final_check : (module Sidekick_sat__.Sigs.ACTS) -> unit

Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.

diff --git a/dev/sidekick/Sidekick_sat/module-type-UNSAT_STATE/index.html b/dev/sidekick/Sidekick_sat/module-type-UNSAT_STATE/index.html index 856de4fa..85b9c862 100644 --- a/dev/sidekick/Sidekick_sat/module-type-UNSAT_STATE/index.html +++ b/dev/sidekick/Sidekick_sat/module-type-UNSAT_STATE/index.html @@ -1,2 +1,2 @@ -UNSAT_STATE (sidekick.Sidekick_sat.UNSAT_STATE)

Module type Sidekick_sat.UNSAT_STATE

Solver in an "UNSATISFIABLE" state

type clause
val unsat_conflict : unit -> clause

Returns the unsat clause found at the toplevel

val unsat_assumptions : unit -> Sidekick_core.Lit.t Iter.t

Subset of assumptions responsible for "unsat"

val unsat_proof : unit -> Sidekick_proof.Step.id
\ No newline at end of file +UNSAT_STATE (sidekick.Sidekick_sat.UNSAT_STATE)

Module type Sidekick_sat.UNSAT_STATE

Solver in an "UNSATISFIABLE" state

type clause
val unsat_conflict : unit -> clause

Returns the unsat clause found at the toplevel

val unsat_assumptions : unit -> Sidekick_core.Lit.t Iter.t

Subset of assumptions responsible for "unsat"

val unsat_proof : unit -> Sidekick_proof.Step.id
diff --git a/dev/sidekick/Sidekick_sigs/.dummy b/dev/sidekick/Sidekick_sigs/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_sigs/index.html b/dev/sidekick/Sidekick_sigs/index.html index 75be5c91..0db5b942 100644 --- a/dev/sidekick/Sidekick_sigs/index.html +++ b/dev/sidekick/Sidekick_sigs/index.html @@ -1,2 +1,2 @@ -Sidekick_sigs (sidekick.Sidekick_sigs)

Module Sidekick_sigs

module type EQ = sig ... end
module type ORD = sig ... end
module type HASH = sig ... end
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
module type PRINT = sig ... end
module type EQ_HASH_PRINT = sig ... end
module type EQ_ORD_HASH_PRINT = sig ... end
module type EQ_ORD_HASH = sig ... end
module type DYN_BACKTRACKABLE = sig ... end
module type BACKTRACKABLE0 = sig ... end
module type BACKTRACKABLE1 = sig ... end
module type BACKTRACKABLE1_CB = sig ... end
module type WITH_SET_MAP_TBL = sig ... end
module type WITH_WEAK = sig ... end
\ No newline at end of file +Sidekick_sigs (sidekick.Sidekick_sigs)

Module Sidekick_sigs

module type EQ = sig ... end
module type ORD = sig ... end
module type HASH = sig ... end
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
module type PRINT = sig ... end
module type EQ_HASH_PRINT = sig ... end
module type EQ_ORD_HASH_PRINT = sig ... end
module type EQ_ORD_HASH = sig ... end
module type DYN_BACKTRACKABLE = sig ... end
module type BACKTRACKABLE0 = sig ... end
module type BACKTRACKABLE1 = sig ... end
module type BACKTRACKABLE1_CB = sig ... end
module type WITH_SET_MAP_TBL = sig ... end
module type WITH_WEAK = sig ... end
diff --git a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE0/index.html b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE0/index.html index f2599a31..baff22f3 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE0/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE0/index.html @@ -1,2 +1,2 @@ -BACKTRACKABLE0 (sidekick.Sidekick_sigs.BACKTRACKABLE0)

Module type Sidekick_sigs.BACKTRACKABLE0

type t
val n_levels : t -> int

Number of levels

val push_level : t -> unit

Push a backtracking point

val pop_levels : t -> int -> unit

pop_levels st n removes n levels

\ No newline at end of file +BACKTRACKABLE0 (sidekick.Sidekick_sigs.BACKTRACKABLE0)

Module type Sidekick_sigs.BACKTRACKABLE0

type t
val n_levels : t -> int

Number of levels

val push_level : t -> unit

Push a backtracking point

val pop_levels : t -> int -> unit

pop_levels st n removes n levels

diff --git a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1/index.html b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1/index.html index 59310a28..0978d04d 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1/index.html @@ -1,2 +1,2 @@ -BACKTRACKABLE1 (sidekick.Sidekick_sigs.BACKTRACKABLE1)

Module type Sidekick_sigs.BACKTRACKABLE1

type 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : _ t -> int -> unit

pop_levels st n removes n levels

\ No newline at end of file +BACKTRACKABLE1 (sidekick.Sidekick_sigs.BACKTRACKABLE1)

Module type Sidekick_sigs.BACKTRACKABLE1

type 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : _ t -> int -> unit

pop_levels st n removes n levels

diff --git a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1_CB/index.html b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1_CB/index.html index 2deb6fcf..0d09a9ba 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1_CB/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1_CB/index.html @@ -1,2 +1,2 @@ -BACKTRACKABLE1_CB (sidekick.Sidekick_sigs.BACKTRACKABLE1_CB)

Module type Sidekick_sigs.BACKTRACKABLE1_CB

include BACKTRACKABLE1
type 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : 'a t -> int -> f:('a -> unit) -> unit

pop_levels st n ~f removes n levels, calling f on every removed item

\ No newline at end of file +BACKTRACKABLE1_CB (sidekick.Sidekick_sigs.BACKTRACKABLE1_CB)

Module type Sidekick_sigs.BACKTRACKABLE1_CB

include BACKTRACKABLE1
type 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : 'a t -> int -> f:('a -> unit) -> unit

pop_levels st n ~f removes n levels, calling f on every removed item

diff --git a/dev/sidekick/Sidekick_sigs/module-type-DYN_BACKTRACKABLE/index.html b/dev/sidekick/Sidekick_sigs/module-type-DYN_BACKTRACKABLE/index.html index a92a0f79..12386bfc 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-DYN_BACKTRACKABLE/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-DYN_BACKTRACKABLE/index.html @@ -1,2 +1,2 @@ -DYN_BACKTRACKABLE (sidekick.Sidekick_sigs.DYN_BACKTRACKABLE)

Module type Sidekick_sigs.DYN_BACKTRACKABLE

val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

\ No newline at end of file +DYN_BACKTRACKABLE (sidekick.Sidekick_sigs.DYN_BACKTRACKABLE)

Module type Sidekick_sigs.DYN_BACKTRACKABLE

val n_levels : unit -> int

Number of levels

val push_level : unit -> unit

Push a backtracking point

val pop_levels : int -> unit

pop_levels n removes n levels

diff --git a/dev/sidekick/Sidekick_sigs/module-type-EQ/index.html b/dev/sidekick/Sidekick_sigs/module-type-EQ/index.html index 7167e1b9..ba47d66d 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-EQ/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-EQ/index.html @@ -1,2 +1,2 @@ -EQ (sidekick.Sidekick_sigs.EQ)

Module type Sidekick_sigs.EQ

type t
val equal : t -> t -> bool
\ No newline at end of file +EQ (sidekick.Sidekick_sigs.EQ)

Module type Sidekick_sigs.EQ

type t
val equal : t -> t -> bool
diff --git a/dev/sidekick/Sidekick_sigs/module-type-EQ_HASH_PRINT/index.html b/dev/sidekick/Sidekick_sigs/module-type-EQ_HASH_PRINT/index.html index 3a9eb227..d134e905 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-EQ_HASH_PRINT/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-EQ_HASH_PRINT/index.html @@ -1,2 +1,2 @@ -EQ_HASH_PRINT (sidekick.Sidekick_sigs.EQ_HASH_PRINT)

Module type Sidekick_sigs.EQ_HASH_PRINT

include EQ
type t
val equal : t -> t -> bool
include HASH with type t := t
val hash : t -> int
include PRINT with type t := t
val pp : t printer
\ No newline at end of file +EQ_HASH_PRINT (sidekick.Sidekick_sigs.EQ_HASH_PRINT)

Module type Sidekick_sigs.EQ_HASH_PRINT

include EQ
type t
val equal : t -> t -> bool
include HASH with type t := t
val hash : t -> int
include PRINT with type t := t
val pp : t printer
diff --git a/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH/index.html b/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH/index.html index e143f463..7f39bf39 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH/index.html @@ -1,2 +1,2 @@ -EQ_ORD_HASH (sidekick.Sidekick_sigs.EQ_ORD_HASH)

Module type Sidekick_sigs.EQ_ORD_HASH

include EQ
type t
val equal : t -> t -> bool
include ORD with type t := t
val compare : t -> t -> int
include HASH with type t := t
val hash : t -> int
\ No newline at end of file +EQ_ORD_HASH (sidekick.Sidekick_sigs.EQ_ORD_HASH)

Module type Sidekick_sigs.EQ_ORD_HASH

include EQ
type t
val equal : t -> t -> bool
include ORD with type t := t
val compare : t -> t -> int
include HASH with type t := t
val hash : t -> int
diff --git a/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH_PRINT/index.html b/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH_PRINT/index.html index 6221d9ee..24fccf30 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH_PRINT/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH_PRINT/index.html @@ -1,2 +1,2 @@ -EQ_ORD_HASH_PRINT (sidekick.Sidekick_sigs.EQ_ORD_HASH_PRINT)

Module type Sidekick_sigs.EQ_ORD_HASH_PRINT

include EQ
type t
val equal : t -> t -> bool
include ORD with type t := t
val compare : t -> t -> int
include HASH with type t := t
val hash : t -> int
include PRINT with type t := t
val pp : t printer
\ No newline at end of file +EQ_ORD_HASH_PRINT (sidekick.Sidekick_sigs.EQ_ORD_HASH_PRINT)

Module type Sidekick_sigs.EQ_ORD_HASH_PRINT

include EQ
type t
val equal : t -> t -> bool
include ORD with type t := t
val compare : t -> t -> int
include HASH with type t := t
val hash : t -> int
include PRINT with type t := t
val pp : t printer
diff --git a/dev/sidekick/Sidekick_sigs/module-type-HASH/index.html b/dev/sidekick/Sidekick_sigs/module-type-HASH/index.html index 579cfdf6..824fe530 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-HASH/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-HASH/index.html @@ -1,2 +1,2 @@ -HASH (sidekick.Sidekick_sigs.HASH)

Module type Sidekick_sigs.HASH

type t
val hash : t -> int
\ No newline at end of file +HASH (sidekick.Sidekick_sigs.HASH)

Module type Sidekick_sigs.HASH

type t
val hash : t -> int
diff --git a/dev/sidekick/Sidekick_sigs/module-type-ORD/index.html b/dev/sidekick/Sidekick_sigs/module-type-ORD/index.html index 73c36f30..1cc7d569 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-ORD/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-ORD/index.html @@ -1,2 +1,2 @@ -ORD (sidekick.Sidekick_sigs.ORD)

Module type Sidekick_sigs.ORD

type t
val compare : t -> t -> int
\ No newline at end of file +ORD (sidekick.Sidekick_sigs.ORD)

Module type Sidekick_sigs.ORD

type t
val compare : t -> t -> int
diff --git a/dev/sidekick/Sidekick_sigs/module-type-PRINT/index.html b/dev/sidekick/Sidekick_sigs/module-type-PRINT/index.html index a640f5f4..ff02c457 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-PRINT/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-PRINT/index.html @@ -1,2 +1,2 @@ -PRINT (sidekick.Sidekick_sigs.PRINT)

Module type Sidekick_sigs.PRINT

type t
val pp : t printer
\ No newline at end of file +PRINT (sidekick.Sidekick_sigs.PRINT)

Module type Sidekick_sigs.PRINT

type t
val pp : t printer
diff --git a/dev/sidekick/Sidekick_sigs/module-type-WITH_SET_MAP_TBL/index.html b/dev/sidekick/Sidekick_sigs/module-type-WITH_SET_MAP_TBL/index.html index 03977a88..d866581e 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-WITH_SET_MAP_TBL/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-WITH_SET_MAP_TBL/index.html @@ -1,2 +1,2 @@ -WITH_SET_MAP_TBL (sidekick.Sidekick_sigs.WITH_SET_MAP_TBL)

Module type Sidekick_sigs.WITH_SET_MAP_TBL

type t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
\ No newline at end of file +WITH_SET_MAP_TBL (sidekick.Sidekick_sigs.WITH_SET_MAP_TBL)

Module type Sidekick_sigs.WITH_SET_MAP_TBL

type t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t
diff --git a/dev/sidekick/Sidekick_sigs/module-type-WITH_WEAK/index.html b/dev/sidekick/Sidekick_sigs/module-type-WITH_WEAK/index.html index de5e1044..821edc6c 100644 --- a/dev/sidekick/Sidekick_sigs/module-type-WITH_WEAK/index.html +++ b/dev/sidekick/Sidekick_sigs/module-type-WITH_WEAK/index.html @@ -1,2 +1,2 @@ -WITH_WEAK (sidekick.Sidekick_sigs.WITH_WEAK)

Module type Sidekick_sigs.WITH_WEAK

type t
module Weak_set : Stdlib.Weak.S with type data = t
module Weak_map : Stdlib.Ephemeron.S with type key = t
\ No newline at end of file +WITH_WEAK (sidekick.Sidekick_sigs.WITH_WEAK)

Module type Sidekick_sigs.WITH_WEAK

type t
module Weak_set : Stdlib.Weak.S with type data = t
module Weak_map : Stdlib.Ephemeron.S with type key = t
diff --git a/dev/sidekick/Sidekick_simplex/.dummy b/dev/sidekick/Sidekick_simplex/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_simplex/Binary_op/index.html b/dev/sidekick/Sidekick_simplex/Binary_op/index.html index fea93104..f16a4bbc 100644 --- a/dev/sidekick/Sidekick_simplex/Binary_op/index.html +++ b/dev/sidekick/Sidekick_simplex/Binary_op/index.html @@ -1,2 +1,2 @@ -Binary_op (sidekick.Sidekick_simplex.Binary_op)

Module Sidekick_simplex.Binary_op

type t =
  1. | Plus
  2. | Minus
val to_string : t -> string
\ No newline at end of file +Binary_op (sidekick.Sidekick_simplex.Binary_op)

Module Sidekick_simplex.Binary_op

type t =
  1. | Plus
  2. | Minus
val to_string : t -> string
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/Infix/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/Infix/index.html index 48e9c2b0..8c03312e 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/Infix/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/Infix/index.html @@ -1,2 +1,2 @@ -Infix (sidekick.Sidekick_simplex.Linear_expr.Make.Comb.Infix)

Module Comb.Infix

Infix operations on combinations

This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between combinations.

val (-) : t -> t -> t

Substraction between combinations.

val (*) : C.t -> t -> t

Multiplication by a constant.

\ No newline at end of file +Infix (sidekick.Sidekick_simplex.Linear_expr.Make.Comb.Infix)

Module Comb.Infix

Infix operations on combinations

This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between combinations.

val (-) : t -> t -> t

Substraction between combinations.

val (*) : C.t -> t -> t

Multiplication by a constant.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/index.html index a2192149..919354eb 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/index.html @@ -1,2 +1,2 @@ -Comb (sidekick.Sidekick_simplex.Linear_expr.Make.Comb)

Module Make.Comb

Combinations.

This module defines linear combnations as mapping from variables to coefficients. This allows for very fast computations.

type t

The type of linear combinations.

val compare : t -> t -> int

Comparisons on linear combinations.

val pp : t Sidekick_util.Fmt.printer

Printer for linear combinations.

val is_empty : t -> bool

Is the given expression empty ?

Creation
val empty : t

The empty linear combination.

val monomial : C.t -> var -> t

monome n v creates the linear combination n * v

val monomial1 : var -> t

monome1 v creates the linear combination 1 * v

val as_singleton : t -> (C.t * var) option

as_singleton l returns Some (c,x) if l = c * x, None otherwise

val add : C.t -> var -> t -> t

add n v t adds the monome n * v to the combination t.

val map : f:(var -> var) -> t -> t
module Infix : sig ... end

Infix operations on combinations

Include the previous module.

include module type of Infix

Infix operations on combinations

This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between combinations.

val (-) : t -> t -> t

Substraction between combinations.

val (*) : C.t -> t -> t

Multiplication by a constant.

val iter : (var -> C.t -> unit) -> t -> unit
val of_list : (C.t * var) list -> t
val to_list : t -> (C.t * var) list

Converters to and from lists of monomes.

val of_map : C.t Var_map.t -> t
val to_map : t -> C.t Var_map.t
Semantics
val eval : subst -> t -> C.t

Evaluate a linear combination given a substitution for its variables. TODO: document potential exceptions raised ?

\ No newline at end of file +Comb (sidekick.Sidekick_simplex.Linear_expr.Make.Comb)

Module Make.Comb

Combinations.

This module defines linear combnations as mapping from variables to coefficients. This allows for very fast computations.

type t

The type of linear combinations.

val compare : t -> t -> int

Comparisons on linear combinations.

val pp : t Sidekick_util.Fmt.printer

Printer for linear combinations.

val is_empty : t -> bool

Is the given expression empty ?

Creation
val empty : t

The empty linear combination.

val monomial : C.t -> var -> t

monome n v creates the linear combination n * v

val monomial1 : var -> t

monome1 v creates the linear combination 1 * v

val as_singleton : t -> (C.t * var) option

as_singleton l returns Some (c,x) if l = c * x, None otherwise

val add : C.t -> var -> t -> t

add n v t adds the monome n * v to the combination t.

val map : f:(var -> var) -> t -> t
module Infix : sig ... end

Infix operations on combinations

Include the previous module.

include module type of Infix

Infix operations on combinations

This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between combinations.

val (-) : t -> t -> t

Substraction between combinations.

val (*) : C.t -> t -> t

Multiplication by a constant.

val iter : (var -> C.t -> unit) -> t -> unit
val of_list : (C.t * var) list -> t
val to_list : t -> (C.t * var) list

Converters to and from lists of monomes.

val of_map : C.t Var_map.t -> t
val to_map : t -> C.t Var_map.t
Semantics
val eval : subst -> t -> C.t

Evaluate a linear combination given a substitution for its variables. TODO: document potential exceptions raised ?

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Constr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Constr/index.html index ab2ceebb..40e8e843 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Constr/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Constr/index.html @@ -1,2 +1,2 @@ -Constr (sidekick.Sidekick_simplex.Linear_expr.Make.Constr)

Module Make.Constr

Linear constraints.

Represents constraints on linear expressions.

Arithmetic comparison operators.

type t = {
  1. expr : Expr.t;
  2. op : op;
}

Linear constraints. Expressions are implicitly compared to zero.

val compare : t -> t -> int

Standard comparison function.

val pp : t Sidekick_util.Fmt.printer

Standard printing function.

val of_expr : Expr.t -> Linear_expr_intf.bool_op -> t
val make : Comb.t -> Linear_expr_intf.bool_op -> C.t -> t

Create a constraint from a linear expression/combination and a constant.

val geq : Comb.t -> C.t -> t
val leq : Comb.t -> C.t -> t
val gt : Comb.t -> C.t -> t
val lt : Comb.t -> C.t -> t
val eq : Comb.t -> C.t -> t
val neq : Comb.t -> C.t -> t
val geq0 : Expr.t -> t
val leq0 : Expr.t -> t
val gt0 : Expr.t -> t
val lt0 : Expr.t -> t
val eq0 : Expr.t -> t
val neq0 : Expr.t -> t
val expr : t -> Expr.t

Extract the given part from a constraint.

Split the linear combinations from the constant

val eval : subst -> t -> bool

Evaluate the given constraint under a substitution.

\ No newline at end of file +Constr (sidekick.Sidekick_simplex.Linear_expr.Make.Constr)

Module Make.Constr

Linear constraints.

Represents constraints on linear expressions.

Arithmetic comparison operators.

type t = {
  1. expr : Expr.t;
  2. op : op;
}

Linear constraints. Expressions are implicitly compared to zero.

val compare : t -> t -> int

Standard comparison function.

val pp : t Sidekick_util.Fmt.printer

Standard printing function.

val of_expr : Expr.t -> Linear_expr_intf.bool_op -> t
val make : Comb.t -> Linear_expr_intf.bool_op -> C.t -> t

Create a constraint from a linear expression/combination and a constant.

val geq : Comb.t -> C.t -> t
val leq : Comb.t -> C.t -> t
val gt : Comb.t -> C.t -> t
val lt : Comb.t -> C.t -> t
val eq : Comb.t -> C.t -> t
val neq : Comb.t -> C.t -> t
val geq0 : Expr.t -> t
val leq0 : Expr.t -> t
val gt0 : Expr.t -> t
val lt0 : Expr.t -> t
val eq0 : Expr.t -> t
val neq0 : Expr.t -> t
val expr : t -> Expr.t

Extract the given part from a constraint.

Split the linear combinations from the constant

val eval : subst -> t -> bool

Evaluate the given constraint under a substitution.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/Infix/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/Infix/index.html index 63e88a4f..d0d9155d 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/Infix/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/Infix/index.html @@ -1,2 +1,2 @@ -Infix (sidekick.Sidekick_simplex.Linear_expr.Make.Expr.Infix)

Module Expr.Infix

Infix operations on expressions

This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between expressions.

val (-) : t -> t -> t

Substraction between expressions.

val (*) : C.t -> t -> t

Multiplication by a constant.

\ No newline at end of file +Infix (sidekick.Sidekick_simplex.Linear_expr.Make.Expr.Infix)

Module Expr.Infix

Infix operations on expressions

This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between expressions.

val (-) : t -> t -> t

Substraction between expressions.

val (*) : C.t -> t -> t

Multiplication by a constant.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/index.html index b45acb28..c86635f2 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/index.html @@ -1,2 +1,2 @@ -Expr (sidekick.Sidekick_simplex.Linear_expr.Make.Expr)

Module Make.Expr

Linear expressions represent linear arithmetic expressions as a linear combination and a constant.

type t

The type of linear expressions.

val comb : t -> Comb.t
val const : t -> C.t
val is_zero : t -> bool
val is_const : t -> bool
val compare : t -> t -> int

Standard comparison function on expressions.

val pp : t Sidekick_util.Fmt.printer

Standard printing function on expressions.

val zero : t

The expression 2.

val of_const : C.t -> t

The constant expression.

val of_comb : Comb.t -> t

Combination without constant

val of_list : C.t -> (C.t * Var.t) list -> t
val make : Comb.t -> C.t -> t

make c n makes the linear expression c + n.

val map : f:(var -> var) -> t -> t
val monomial : C.t -> var -> t
val monomial1 : var -> t
module Infix : sig ... end

Infix operations on expressions

Include the previous module.

include module type of Infix

Infix operations on expressions

This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between expressions.

val (-) : t -> t -> t

Substraction between expressions.

val (*) : C.t -> t -> t

Multiplication by a constant.

Semantics
val eval : subst -> t -> C.t

Evaluate a linear expression given a substitution for its variables. TODO: document potential exceptions raised ?

\ No newline at end of file +Expr (sidekick.Sidekick_simplex.Linear_expr.Make.Expr)

Module Make.Expr

Linear expressions represent linear arithmetic expressions as a linear combination and a constant.

type t

The type of linear expressions.

val comb : t -> Comb.t
val const : t -> C.t
val is_zero : t -> bool
val is_const : t -> bool
val compare : t -> t -> int

Standard comparison function on expressions.

val pp : t Sidekick_util.Fmt.printer

Standard printing function on expressions.

val zero : t

The expression 2.

val of_const : C.t -> t

The constant expression.

val of_comb : Comb.t -> t

Combination without constant

val of_list : C.t -> (C.t * Var.t) list -> t
val make : Comb.t -> C.t -> t

make c n makes the linear expression c + n.

val map : f:(var -> var) -> t -> t
val monomial : C.t -> var -> t
val monomial1 : var -> t
module Infix : sig ... end

Infix operations on expressions

Include the previous module.

include module type of Infix

Infix operations on expressions

This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between expressions.

val (-) : t -> t -> t

Substraction between expressions.

val (*) : C.t -> t -> t

Multiplication by a constant.

Semantics
val eval : subst -> t -> C.t

Evaluate a linear expression given a substitution for its variables. TODO: document potential exceptions raised ?

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-1-C/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-1-C/index.html index 5348da04..7d065796 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-1-C/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-1-C/index.html @@ -1,2 +1,2 @@ -C (sidekick.Sidekick_simplex.Linear_expr.Make.C)

Parameter Make.C

type t
val equal : t -> t -> bool

Equality on coefficients.

val compare : t -> t -> int

Comparison on coefficients.

val pp : t Sidekick_util.Fmt.printer

Printer for coefficients.

val zero : t

The zero coefficient.

val one : t

The one coefficient (to rule them all, :p).

val neg : t -> t

Unary negation

val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t

Standard operations on coefficients.

\ No newline at end of file +C (sidekick.Sidekick_simplex.Linear_expr.Make.C)

Parameter Make.C

type t
val equal : t -> t -> bool

Equality on coefficients.

val compare : t -> t -> int

Comparison on coefficients.

val pp : t Sidekick_util.Fmt.printer

Printer for coefficients.

val zero : t

The zero coefficient.

val one : t

The one coefficient (to rule them all, :p).

val neg : t -> t

Unary negation

val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t

Standard operations on coefficients.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-2-Var/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-2-Var/index.html index b7548702..2490c45a 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-2-Var/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-2-Var/index.html @@ -1,2 +1,2 @@ -Var (sidekick.Sidekick_simplex.Linear_expr.Make.Var)

Parameter Make.Var

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file +Var (sidekick.Sidekick_simplex.Linear_expr.Make.Var)

Parameter Make.Var

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/index.html index a3e2c00f..48c3e8c8 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/index.html @@ -1,2 +1,2 @@ -Make (sidekick.Sidekick_simplex.Linear_expr.Make)

Module Linear_expr.Make

Parameters

module C : COEFF
module Var : VAR

Signature

module C = C

Coeficients used. Can be integers as well as rationals.

module Var = Var

Variables used in expressions.

type var = Var.t

The type of variables appearing in expressions.

module Var_map = CCMap.Make(Var)

Maps from variables, used for expressions as well as substitutions.

type subst = Var.t -> C.t

Type for substitutions.

module Comb : sig ... end

Combinations.

Linear expressions.

module Expr : sig ... end

Linear expressions represent linear arithmetic expressions as a linear combination and a constant.

module Constr : sig ... end
\ No newline at end of file +Make (sidekick.Sidekick_simplex.Linear_expr.Make)

Module Linear_expr.Make

Parameters

module C : COEFF
module Var : VAR

Signature

module C = C

Coeficients used. Can be integers as well as rationals.

module Var = Var

Variables used in expressions.

type var = Var.t

The type of variables appearing in expressions.

module Var_map = CCMap.Make(Var)

Maps from variables, used for expressions as well as substitutions.

type subst = Var.t -> C.t

Type for substitutions.

module Comb : sig ... end

Combinations.

Linear expressions.

module Expr : sig ... end

Linear expressions represent linear arithmetic expressions as a linear combination and a constant.

module Constr : sig ... end
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/index.html index 131ff1b2..2ecdc678 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr/index.html @@ -1,5 +1,5 @@ -Linear_expr (sidekick.Sidekick_simplex.Linear_expr)

Module Sidekick_simplex.Linear_expr

Arithmetic expressions

module type COEFF = Linear_expr_intf.COEFF
module type VAR = Linear_expr_intf.VAR
module type S = Linear_expr_intf.S
type nonrec bool_op = Linear_expr_intf.bool_op =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
module Make +Linear_expr (sidekick.Sidekick_simplex.Linear_expr)

Module Sidekick_simplex.Linear_expr

Arithmetic expressions

module type COEFF = Linear_expr_intf.COEFF
module type VAR = Linear_expr_intf.VAR
module type S = Linear_expr_intf.S
type nonrec bool_op = Linear_expr_intf.bool_op =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
module Make (C : COEFF) (Var : VAR) : - S with module C = C and module Var = Var and module Var_map = CCMap.Make(Var)
\ No newline at end of file + S with module C = C and module Var = Var and module Var_map = CCMap.Make(Var)
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/index.html index 5fd86162..a88c9de9 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/index.html @@ -1,2 +1,2 @@ -Linear_expr_intf (sidekick.Sidekick_simplex.Linear_expr_intf)

Module Sidekick_simplex.Linear_expr_intf

Linear expressions interface

module type COEFF = sig ... end
module type VAR = sig ... end
type bool_op = Predicate.t =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
type op = Binary_op.t =
  1. | Plus
  2. | Minus

Linear expressions & formulas

module type S = sig ... end

Linear expressions & formulas.

\ No newline at end of file +Linear_expr_intf (sidekick.Sidekick_simplex.Linear_expr_intf)

Module Sidekick_simplex.Linear_expr_intf

Linear expressions interface

module type COEFF = sig ... end
module type VAR = sig ... end
type bool_op = Predicate.t =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
type op = Binary_op.t =
  1. | Plus
  2. | Minus

Linear expressions & formulas

module type S = sig ... end

Linear expressions & formulas.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-COEFF/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-COEFF/index.html index 86e8c7bc..deecbb44 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-COEFF/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-COEFF/index.html @@ -1,2 +1,2 @@ -COEFF (sidekick.Sidekick_simplex.Linear_expr_intf.COEFF)

Module type Linear_expr_intf.COEFF

Coefficients

Coefficients are used in expressions. They usually are either rationals, or integers.

type t
val equal : t -> t -> bool

Equality on coefficients.

val compare : t -> t -> int

Comparison on coefficients.

val pp : t Sidekick_util.Fmt.printer

Printer for coefficients.

val zero : t

The zero coefficient.

val one : t

The one coefficient (to rule them all, :p).

val neg : t -> t

Unary negation

val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t

Standard operations on coefficients.

\ No newline at end of file +COEFF (sidekick.Sidekick_simplex.Linear_expr_intf.COEFF)

Module type Linear_expr_intf.COEFF

Coefficients

Coefficients are used in expressions. They usually are either rationals, or integers.

type t
val equal : t -> t -> bool

Equality on coefficients.

val compare : t -> t -> int

Comparison on coefficients.

val pp : t Sidekick_util.Fmt.printer

Printer for coefficients.

val zero : t

The zero coefficient.

val one : t

The one coefficient (to rule them all, :p).

val neg : t -> t

Unary negation

val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t

Standard operations on coefficients.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/C/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/C/index.html index e55ae45d..59e06bb6 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/C/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/C/index.html @@ -1,2 +1,2 @@ -C (sidekick.Sidekick_simplex.Linear_expr_intf.S.C)

Module S.C

Coeficients used. Can be integers as well as rationals.

type t
val equal : t -> t -> bool

Equality on coefficients.

val compare : t -> t -> int

Comparison on coefficients.

val pp : t Sidekick_util.Fmt.printer

Printer for coefficients.

val zero : t

The zero coefficient.

val one : t

The one coefficient (to rule them all, :p).

val neg : t -> t

Unary negation

val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t

Standard operations on coefficients.

\ No newline at end of file +C (sidekick.Sidekick_simplex.Linear_expr_intf.S.C)

Module S.C

Coeficients used. Can be integers as well as rationals.

type t
val equal : t -> t -> bool

Equality on coefficients.

val compare : t -> t -> int

Comparison on coefficients.

val pp : t Sidekick_util.Fmt.printer

Printer for coefficients.

val zero : t

The zero coefficient.

val one : t

The one coefficient (to rule them all, :p).

val neg : t -> t

Unary negation

val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t

Standard operations on coefficients.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/Infix/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/Infix/index.html index ecc97ef1..f55f8837 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/Infix/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/Infix/index.html @@ -1,2 +1,2 @@ -Infix (sidekick.Sidekick_simplex.Linear_expr_intf.S.Comb.Infix)

Module Comb.Infix

Infix operations on combinations

This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between combinations.

val (-) : t -> t -> t

Substraction between combinations.

val (*) : C.t -> t -> t

Multiplication by a constant.

\ No newline at end of file +Infix (sidekick.Sidekick_simplex.Linear_expr_intf.S.Comb.Infix)

Module Comb.Infix

Infix operations on combinations

This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between combinations.

val (-) : t -> t -> t

Substraction between combinations.

val (*) : C.t -> t -> t

Multiplication by a constant.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/index.html index 64f4cf2d..a7e8e3c6 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/index.html @@ -1,2 +1,2 @@ -Comb (sidekick.Sidekick_simplex.Linear_expr_intf.S.Comb)

Module S.Comb

Combinations.

This module defines linear combnations as mapping from variables to coefficients. This allows for very fast computations.

type t

The type of linear combinations.

val compare : t -> t -> int

Comparisons on linear combinations.

val pp : t Sidekick_util.Fmt.printer

Printer for linear combinations.

val is_empty : t -> bool

Is the given expression empty ?

Creation
val empty : t

The empty linear combination.

val monomial : C.t -> var -> t

monome n v creates the linear combination n * v

val monomial1 : var -> t

monome1 v creates the linear combination 1 * v

val as_singleton : t -> (C.t * var) option

as_singleton l returns Some (c,x) if l = c * x, None otherwise

val add : C.t -> var -> t -> t

add n v t adds the monome n * v to the combination t.

val map : f:(var -> var) -> t -> t
module Infix : sig ... end

Infix operations on combinations

Include the previous module.

include module type of Infix

Infix operations on combinations

This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between combinations.

val (-) : t -> t -> t

Substraction between combinations.

val (*) : C.t -> t -> t

Multiplication by a constant.

val iter : (var -> C.t -> unit) -> t -> unit
val of_list : (C.t * var) list -> t
val to_list : t -> (C.t * var) list

Converters to and from lists of monomes.

val of_map : C.t Var_map.t -> t
val to_map : t -> C.t Var_map.t
Semantics
val eval : subst -> t -> C.t

Evaluate a linear combination given a substitution for its variables. TODO: document potential exceptions raised ?

\ No newline at end of file +Comb (sidekick.Sidekick_simplex.Linear_expr_intf.S.Comb)

Module S.Comb

Combinations.

This module defines linear combnations as mapping from variables to coefficients. This allows for very fast computations.

type t

The type of linear combinations.

val compare : t -> t -> int

Comparisons on linear combinations.

val pp : t Sidekick_util.Fmt.printer

Printer for linear combinations.

val is_empty : t -> bool

Is the given expression empty ?

Creation
val empty : t

The empty linear combination.

val monomial : C.t -> var -> t

monome n v creates the linear combination n * v

val monomial1 : var -> t

monome1 v creates the linear combination 1 * v

val as_singleton : t -> (C.t * var) option

as_singleton l returns Some (c,x) if l = c * x, None otherwise

val add : C.t -> var -> t -> t

add n v t adds the monome n * v to the combination t.

val map : f:(var -> var) -> t -> t
module Infix : sig ... end

Infix operations on combinations

Include the previous module.

include module type of Infix

Infix operations on combinations

This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between combinations.

val (-) : t -> t -> t

Substraction between combinations.

val (*) : C.t -> t -> t

Multiplication by a constant.

val iter : (var -> C.t -> unit) -> t -> unit
val of_list : (C.t * var) list -> t
val to_list : t -> (C.t * var) list

Converters to and from lists of monomes.

val of_map : C.t Var_map.t -> t
val to_map : t -> C.t Var_map.t
Semantics
val eval : subst -> t -> C.t

Evaluate a linear combination given a substitution for its variables. TODO: document potential exceptions raised ?

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Constr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Constr/index.html index 4c1eaf60..4e47cf64 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Constr/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Constr/index.html @@ -1,2 +1,2 @@ -Constr (sidekick.Sidekick_simplex.Linear_expr_intf.S.Constr)

Module S.Constr

Linear constraints.

Represents constraints on linear expressions.

type op = bool_op

Arithmetic comparison operators.

type t = {
  1. expr : Expr.t;
  2. op : op;
}

Linear constraints. Expressions are implicitly compared to zero.

val compare : t -> t -> int

Standard comparison function.

val pp : t Sidekick_util.Fmt.printer

Standard printing function.

val of_expr : Expr.t -> bool_op -> t
val make : Comb.t -> bool_op -> C.t -> t

Create a constraint from a linear expression/combination and a constant.

val geq : Comb.t -> C.t -> t
val leq : Comb.t -> C.t -> t
val gt : Comb.t -> C.t -> t
val lt : Comb.t -> C.t -> t
val eq : Comb.t -> C.t -> t
val neq : Comb.t -> C.t -> t
val geq0 : Expr.t -> t
val leq0 : Expr.t -> t
val gt0 : Expr.t -> t
val lt0 : Expr.t -> t
val eq0 : Expr.t -> t
val neq0 : Expr.t -> t
val op : t -> bool_op
val expr : t -> Expr.t

Extract the given part from a constraint.

val split : t -> Comb.t * bool_op * C.t

Split the linear combinations from the constant

val eval : subst -> t -> bool

Evaluate the given constraint under a substitution.

\ No newline at end of file +Constr (sidekick.Sidekick_simplex.Linear_expr_intf.S.Constr)

Module S.Constr

Linear constraints.

Represents constraints on linear expressions.

type op = bool_op

Arithmetic comparison operators.

type t = {
  1. expr : Expr.t;
  2. op : op;
}

Linear constraints. Expressions are implicitly compared to zero.

val compare : t -> t -> int

Standard comparison function.

val pp : t Sidekick_util.Fmt.printer

Standard printing function.

val of_expr : Expr.t -> bool_op -> t
val make : Comb.t -> bool_op -> C.t -> t

Create a constraint from a linear expression/combination and a constant.

val geq : Comb.t -> C.t -> t
val leq : Comb.t -> C.t -> t
val gt : Comb.t -> C.t -> t
val lt : Comb.t -> C.t -> t
val eq : Comb.t -> C.t -> t
val neq : Comb.t -> C.t -> t
val geq0 : Expr.t -> t
val leq0 : Expr.t -> t
val gt0 : Expr.t -> t
val lt0 : Expr.t -> t
val eq0 : Expr.t -> t
val neq0 : Expr.t -> t
val op : t -> bool_op
val expr : t -> Expr.t

Extract the given part from a constraint.

val split : t -> Comb.t * bool_op * C.t

Split the linear combinations from the constant

val eval : subst -> t -> bool

Evaluate the given constraint under a substitution.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/Infix/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/Infix/index.html index a2589161..fba53cd5 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/Infix/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/Infix/index.html @@ -1,2 +1,2 @@ -Infix (sidekick.Sidekick_simplex.Linear_expr_intf.S.Expr.Infix)

Module Expr.Infix

Infix operations on expressions

This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between expressions.

val (-) : t -> t -> t

Substraction between expressions.

val (*) : C.t -> t -> t

Multiplication by a constant.

\ No newline at end of file +Infix (sidekick.Sidekick_simplex.Linear_expr_intf.S.Expr.Infix)

Module Expr.Infix

Infix operations on expressions

This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between expressions.

val (-) : t -> t -> t

Substraction between expressions.

val (*) : C.t -> t -> t

Multiplication by a constant.

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/index.html index c4f67712..bcf31f92 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/index.html @@ -1,2 +1,2 @@ -Expr (sidekick.Sidekick_simplex.Linear_expr_intf.S.Expr)

Module S.Expr

Linear expressions represent linear arithmetic expressions as a linear combination and a constant.

type t

The type of linear expressions.

val comb : t -> Comb.t
val const : t -> C.t
val is_zero : t -> bool
val is_const : t -> bool
val compare : t -> t -> int

Standard comparison function on expressions.

val pp : t Sidekick_util.Fmt.printer

Standard printing function on expressions.

val zero : t

The expression 2.

val of_const : C.t -> t

The constant expression.

val of_comb : Comb.t -> t

Combination without constant

val of_list : C.t -> (C.t * Var.t) list -> t
val make : Comb.t -> C.t -> t

make c n makes the linear expression c + n.

val map : f:(var -> var) -> t -> t
val monomial : C.t -> var -> t
val monomial1 : var -> t
module Infix : sig ... end

Infix operations on expressions

Include the previous module.

include module type of Infix

Infix operations on expressions

This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between expressions.

val (-) : t -> t -> t

Substraction between expressions.

val (*) : C.t -> t -> t

Multiplication by a constant.

Semantics
val eval : subst -> t -> C.t

Evaluate a linear expression given a substitution for its variables. TODO: document potential exceptions raised ?

\ No newline at end of file +Expr (sidekick.Sidekick_simplex.Linear_expr_intf.S.Expr)

Module S.Expr

Linear expressions represent linear arithmetic expressions as a linear combination and a constant.

type t

The type of linear expressions.

val comb : t -> Comb.t
val const : t -> C.t
val is_zero : t -> bool
val is_const : t -> bool
val compare : t -> t -> int

Standard comparison function on expressions.

val pp : t Sidekick_util.Fmt.printer

Standard printing function on expressions.

val zero : t

The expression 2.

val of_const : C.t -> t

The constant expression.

val of_comb : Comb.t -> t

Combination without constant

val of_list : C.t -> (C.t * Var.t) list -> t
val make : Comb.t -> C.t -> t

make c n makes the linear expression c + n.

val map : f:(var -> var) -> t -> t
val monomial : C.t -> var -> t
val monomial1 : var -> t
module Infix : sig ... end

Infix operations on expressions

Include the previous module.

include module type of Infix

Infix operations on expressions

This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.

val (+) : t -> t -> t

Addition between expressions.

val (-) : t -> t -> t

Substraction between expressions.

val (*) : C.t -> t -> t

Multiplication by a constant.

Semantics
val eval : subst -> t -> C.t

Evaluate a linear expression given a substitution for its variables. TODO: document potential exceptions raised ?

diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Var/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Var/index.html index 33b6d2d5..335eb511 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Var/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Var/index.html @@ -1,2 +1,2 @@ -Var (sidekick.Sidekick_simplex.Linear_expr_intf.S.Var)

Module S.Var

Variables used in expressions.

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file +Var (sidekick.Sidekick_simplex.Linear_expr_intf.S.Var)

Module S.Var

Variables used in expressions.

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/index.html index 1aace506..768bd952 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/index.html @@ -1,2 +1,2 @@ -S (sidekick.Sidekick_simplex.Linear_expr_intf.S)

Module type Linear_expr_intf.S

Linear expressions & formulas.

This modules defines linear expressions (which are linear combinations of variables), and linear constraints, where the value of a linear expressions is constrained.

module C : COEFF

Coeficients used. Can be integers as well as rationals.

module Var : VAR

Variables used in expressions.

type var = Var.t

The type of variables appearing in expressions.

module Var_map : CCMap.S with type key = var

Maps from variables, used for expressions as well as substitutions.

type subst = Var.t -> C.t

Type for substitutions.

module Comb : sig ... end

Combinations.

Linear expressions.

module Expr : sig ... end

Linear expressions represent linear arithmetic expressions as a linear combination and a constant.

module Constr : sig ... end
\ No newline at end of file +S (sidekick.Sidekick_simplex.Linear_expr_intf.S)

Module type Linear_expr_intf.S

Linear expressions & formulas.

This modules defines linear expressions (which are linear combinations of variables), and linear constraints, where the value of a linear expressions is constrained.

module C : COEFF

Coeficients used. Can be integers as well as rationals.

module Var : VAR

Variables used in expressions.

type var = Var.t

The type of variables appearing in expressions.

module Var_map : CCMap.S with type key = var

Maps from variables, used for expressions as well as substitutions.

type subst = Var.t -> C.t

Type for substitutions.

module Comb : sig ... end

Combinations.

Linear expressions.

module Expr : sig ... end

Linear expressions represent linear arithmetic expressions as a linear combination and a constant.

module Constr : sig ... end
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-VAR/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-VAR/index.html index bff8826b..925368c7 100644 --- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-VAR/index.html +++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-VAR/index.html @@ -1,2 +1,2 @@ -VAR (sidekick.Sidekick_simplex.Linear_expr_intf.VAR)

Module type Linear_expr_intf.VAR

Variable interface

Standard interface for variables that are meant to be used in expressions.

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file +VAR (sidekick.Sidekick_simplex.Linear_expr_intf.VAR)

Module type Linear_expr_intf.VAR

Variable interface

Standard interface for variables that are meant to be used in expressions.

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
diff --git a/dev/sidekick/Sidekick_simplex/Make/Constraint/index.html b/dev/sidekick/Sidekick_simplex/Make/Constraint/index.html index 8d8e25e0..c5036b28 100644 --- a/dev/sidekick/Sidekick_simplex/Make/Constraint/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/Constraint/index.html @@ -1,2 +1,2 @@ -Constraint (sidekick.Sidekick_simplex.Make.Constraint)

Module Make.Constraint

type op = Op.t
type t = {
  1. op : op;
  2. lhs : V.t;
  3. rhs : num;
}

A constraint is the comparison of a variable to a constant.

val mk : V.t -> op -> num -> t
val leq : V.t -> num -> t
val lt : V.t -> num -> t
val geq : V.t -> num -> t
val gt : V.t -> num -> t
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file +Constraint (sidekick.Sidekick_simplex.Make.Constraint)

Module Make.Constraint

type op = Op.t
type t = {
  1. op : op;
  2. lhs : V.t;
  3. rhs : num;
}

A constraint is the comparison of a variable to a constant.

val mk : V.t -> op -> num -> t
val leq : V.t -> num -> t
val lt : V.t -> num -> t
val geq : V.t -> num -> t
val gt : V.t -> num -> t
val pp : t Sidekick_util.Fmt.printer
diff --git a/dev/sidekick/Sidekick_simplex/Make/Subst/index.html b/dev/sidekick/Sidekick_simplex/Make/Subst/index.html index 4caeeb3c..6099482f 100644 --- a/dev/sidekick/Sidekick_simplex/Make/Subst/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/Subst/index.html @@ -1,2 +1,2 @@ -Subst (sidekick.Sidekick_simplex.Make.Subst)

Module Make.Subst

type t = num V_map.t
val eval : t -> V.t -> Q.t option
val to_iter : t -> (V.t * Q.t) Iter.t
val pp : t Sidekick_util.Fmt.printer
val to_string : t -> string
\ No newline at end of file +Subst (sidekick.Sidekick_simplex.Make.Subst)

Module Make.Subst

type t = num V_map.t
val eval : t -> V.t -> Q.t option
val to_iter : t -> (V.t * Q.t) Iter.t
val pp : t Sidekick_util.Fmt.printer
val to_string : t -> string
diff --git a/dev/sidekick/Sidekick_simplex/Make/Unsat_cert/index.html b/dev/sidekick/Sidekick_simplex/Make/Unsat_cert/index.html index 483ee86a..8b653240 100644 --- a/dev/sidekick/Sidekick_simplex/Make/Unsat_cert/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/Unsat_cert/index.html @@ -1,2 +1,2 @@ -Unsat_cert (sidekick.Sidekick_simplex.Make.Unsat_cert)

Module Make.Unsat_cert

type t = unsat_cert
val lits : t -> V.lit list
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file +Unsat_cert (sidekick.Sidekick_simplex.Make.Unsat_cert)

Module Make.Unsat_cert

type t = unsat_cert
val lits : t -> V.lit list
val pp : t Sidekick_util.Fmt.printer
diff --git a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Q/index.html b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Q/index.html index bda214fc..914ba965 100644 --- a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Q/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_simplex.Make.Arg.Q)

Module Arg.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_simplex.Make.Arg.Q)

Module Arg.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

diff --git a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Var/index.html b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Var/index.html index d254433d..c9258ef8 100644 --- a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Var/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Var/index.html @@ -1,2 +1,2 @@ -Var (sidekick.Sidekick_simplex.Make.Arg.Var)

Module Arg.Var

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file +Var (sidekick.Sidekick_simplex.Make.Arg.Var)

Module Arg.Var

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
diff --git a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Z/index.html b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Z/index.html index 96c204f8..472e5f39 100644 --- a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Z/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Z/index.html @@ -1,2 +1,2 @@ -Z (sidekick.Sidekick_simplex.Make.Arg.Z)

Module Arg.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file +Z (sidekick.Sidekick_simplex.Make.Arg.Z)

Module Arg.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
diff --git a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/index.html b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/index.html index cfeac085..29680c5c 100644 --- a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/index.html @@ -1,2 +1,2 @@ -Arg (sidekick.Sidekick_simplex.Make.Arg)

Parameter Make.Arg

module Z : INT
module Q : RATIONAL with type bigint = Z.t
module Var : VAR
val mk_lit : Var.t -> Op.t -> Q.t -> Var.lit

Create new literals

\ No newline at end of file +Arg (sidekick.Sidekick_simplex.Make.Arg)

Parameter Make.Arg

module Z : INT
module Q : RATIONAL with type bigint = Z.t
module Var : VAR
val mk_lit : Var.t -> Op.t -> Q.t -> Var.lit

Create new literals

diff --git a/dev/sidekick/Sidekick_simplex/Make/index.html b/dev/sidekick/Sidekick_simplex/Make/index.html index 2e704310..6f6745b1 100644 --- a/dev/sidekick/Sidekick_simplex/Make/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/index.html @@ -1,12 +1,12 @@ -Make (sidekick.Sidekick_simplex.Make)

Module Sidekick_simplex.Make

Parameters

module Arg : ARG

Signature

module V = Arg.Var
module V_map : CCMap.S with type key = V.t
module Z = Arg.Z
module Q = Arg.Q
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?is_int:bool -> - on_propagate:ev_on_propagate -> +Make (sidekick.Sidekick_simplex.Make)

Module Sidekick_simplex.Make

Parameters

module Arg : ARG

Signature

module V = Arg.Var
module V_map : CCMap.S with type key = V.t
module Z = Arg.Z
module Q = Arg.Q
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : + ?is_int:bool -> + on_propagate:ev_on_propagate -> t -> Constraint.t -> V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:(V.lit -> reason:V.lit list -> unit) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
  1. | Sat of Subst.t
  2. | Unsat of Unsat_cert.t
val check : on_propagate:(V.lit -> reason:V.lit list -> unit) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : - on_propagate:(V.lit -> reason:V.lit list -> unit) -> - max_tree_nodes:int -> + unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:(V.lit -> reason:V.lit list -> unit) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
  1. | Sat of Subst.t
  2. | Unsat of Unsat_cert.t
val check : on_propagate:(V.lit -> reason:V.lit list -> unit) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : + on_propagate:(V.lit -> reason:V.lit list -> unit) -> + max_tree_nodes:int -> t -> - result option

Try to solve and respect the integer constraints.

val n_vars : t -> int
val n_rows : t -> int
\ No newline at end of file + result option

Try to solve and respect the integer constraints.

val n_vars : t -> int
val n_rows : t -> int
diff --git a/dev/sidekick/Sidekick_simplex/Op/index.html b/dev/sidekick/Sidekick_simplex/Op/index.html index f05fd26e..13e001b3 100644 --- a/dev/sidekick/Sidekick_simplex/Op/index.html +++ b/dev/sidekick/Sidekick_simplex/Op/index.html @@ -1,2 +1,2 @@ -Op (sidekick.Sidekick_simplex.Op)

Module Sidekick_simplex.Op

Simplex operator

type t =
  1. | Leq
  2. | Lt
  3. | Geq
  4. | Gt
val neg_sign : t -> t
val not_ : t -> t
val to_string : t -> string
val pp : Sidekick_util.Fmt.t -> t -> unit
\ No newline at end of file +Op (sidekick.Sidekick_simplex.Op)

Module Sidekick_simplex.Op

Simplex operator

type t =
  1. | Leq
  2. | Lt
  3. | Geq
  4. | Gt
val neg_sign : t -> t
val not_ : t -> t
val to_string : t -> string
val pp : Sidekick_util.Fmt.t -> t -> unit
diff --git a/dev/sidekick/Sidekick_simplex/Predicate/index.html b/dev/sidekick/Sidekick_simplex/Predicate/index.html index f43da297..dbdfc8f0 100644 --- a/dev/sidekick/Sidekick_simplex/Predicate/index.html +++ b/dev/sidekick/Sidekick_simplex/Predicate/index.html @@ -1,2 +1,2 @@ -Predicate (sidekick.Sidekick_simplex.Predicate)

Module Sidekick_simplex.Predicate

type t =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
val neg : t -> t
val neg_sign : t -> t
val to_string : t -> string
val pp : Sidekick_util.Fmt.t -> t -> unit
\ No newline at end of file +Predicate (sidekick.Sidekick_simplex.Predicate)

Module Sidekick_simplex.Predicate

type t =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
val neg : t -> t
val neg_sign : t -> t
val to_string : t -> string
val pp : Sidekick_util.Fmt.t -> t -> unit
diff --git a/dev/sidekick/Sidekick_simplex/index.html b/dev/sidekick/Sidekick_simplex/index.html index 40e8cb9c..8cd39f4f 100644 --- a/dev/sidekick/Sidekick_simplex/index.html +++ b/dev/sidekick/Sidekick_simplex/index.html @@ -1,4 +1,4 @@ -Sidekick_simplex (sidekick.Sidekick_simplex)

Module Sidekick_simplex

Fast Simplex for CDCL(T)

We follow the paper "Integrating Simplex with DPLL(T )" from de Moura and Dutertre.

module Linear_expr_intf : sig ... end
module Linear_expr : sig ... end

Arithmetic expressions

module Predicate : sig ... end
module Binary_op : sig ... end
module type INT = Sidekick_arith.INT
module type RATIONAL = Sidekick_arith.RATIONAL
module type VAR = Linear_expr_intf.VAR
module Op : sig ... end

Simplex operator

module type S = sig ... end
module type ARG = sig ... end
module Make +Sidekick_simplex (sidekick.Sidekick_simplex)

Module Sidekick_simplex

Fast Simplex for CDCL(T)

We follow the paper "Integrating Simplex with DPLL(T )" from de Moura and Dutertre.

module Linear_expr_intf : sig ... end
module Linear_expr : sig ... end

Arithmetic expressions

module Predicate : sig ... end
module Binary_op : sig ... end
module type INT = Sidekick_arith.INT
module type RATIONAL = Sidekick_arith.RATIONAL
module type VAR = Linear_expr_intf.VAR
module Op : sig ... end

Simplex operator

module type S = sig ... end
module type ARG = sig ... end
module Make (Arg : ARG) : - S with module V = Arg.Var and module Z = Arg.Z and module Q = Arg.Q
\ No newline at end of file + S with module V = Arg.Var and module Z = Arg.Z and module Q = Arg.Q
diff --git a/dev/sidekick/Sidekick_simplex/module-type-ARG/Q/index.html b/dev/sidekick/Sidekick_simplex/module-type-ARG/Q/index.html index bb31293b..1a9c1f4d 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-ARG/Q/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-ARG/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_simplex.ARG.Q)

Module ARG.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_simplex.ARG.Q)

Module ARG.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

diff --git a/dev/sidekick/Sidekick_simplex/module-type-ARG/Var/index.html b/dev/sidekick/Sidekick_simplex/module-type-ARG/Var/index.html index ad70b901..63151a78 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-ARG/Var/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-ARG/Var/index.html @@ -1,2 +1,2 @@ -Var (sidekick.Sidekick_simplex.ARG.Var)

Module ARG.Var

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file +Var (sidekick.Sidekick_simplex.ARG.Var)

Module ARG.Var

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
diff --git a/dev/sidekick/Sidekick_simplex/module-type-ARG/Z/index.html b/dev/sidekick/Sidekick_simplex/module-type-ARG/Z/index.html index b7a58170..b065643a 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-ARG/Z/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-ARG/Z/index.html @@ -1,2 +1,2 @@ -Z (sidekick.Sidekick_simplex.ARG.Z)

Module ARG.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file +Z (sidekick.Sidekick_simplex.ARG.Z)

Module ARG.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
diff --git a/dev/sidekick/Sidekick_simplex/module-type-ARG/index.html b/dev/sidekick/Sidekick_simplex/module-type-ARG/index.html index 5ad33814..5fae058d 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-ARG/index.html @@ -1,2 +1,2 @@ -ARG (sidekick.Sidekick_simplex.ARG)

Module type Sidekick_simplex.ARG

module Z : INT
module Q : RATIONAL with type bigint = Z.t
module Var : VAR
val mk_lit : Var.t -> Op.t -> Q.t -> Var.lit

Create new literals

\ No newline at end of file +ARG (sidekick.Sidekick_simplex.ARG)

Module type Sidekick_simplex.ARG

module Z : INT
module Q : RATIONAL with type bigint = Z.t
module Var : VAR
val mk_lit : Var.t -> Op.t -> Q.t -> Var.lit

Create new literals

diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Constraint/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Constraint/index.html index 52dea288..7f508faf 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-S/Constraint/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-S/Constraint/index.html @@ -1,2 +1,2 @@ -Constraint (sidekick.Sidekick_simplex.S.Constraint)

Module S.Constraint

type op = Op.t
type t = {
  1. op : op;
  2. lhs : V.t;
  3. rhs : num;
}

A constraint is the comparison of a variable to a constant.

val mk : V.t -> op -> num -> t
val leq : V.t -> num -> t
val lt : V.t -> num -> t
val geq : V.t -> num -> t
val gt : V.t -> num -> t
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file +Constraint (sidekick.Sidekick_simplex.S.Constraint)

Module S.Constraint

type op = Op.t
type t = {
  1. op : op;
  2. lhs : V.t;
  3. rhs : num;
}

A constraint is the comparison of a variable to a constant.

val mk : V.t -> op -> num -> t
val leq : V.t -> num -> t
val lt : V.t -> num -> t
val geq : V.t -> num -> t
val gt : V.t -> num -> t
val pp : t Sidekick_util.Fmt.printer
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Q/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Q/index.html index 51cb5051..c31f78b0 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-S/Q/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-S/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_simplex.S.Q)

Module S.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_simplex.S.Q)

Module S.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Subst/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Subst/index.html index 29dfbab6..c9ca6ecc 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-S/Subst/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-S/Subst/index.html @@ -1,2 +1,2 @@ -Subst (sidekick.Sidekick_simplex.S.Subst)

Module S.Subst

type t = num V_map.t
val eval : t -> V.t -> Q.t option
val to_iter : t -> (V.t * Q.t) Iter.t
val pp : t Sidekick_util.Fmt.printer
val to_string : t -> string
\ No newline at end of file +Subst (sidekick.Sidekick_simplex.S.Subst)

Module S.Subst

type t = num V_map.t
val eval : t -> V.t -> Q.t option
val to_iter : t -> (V.t * Q.t) Iter.t
val pp : t Sidekick_util.Fmt.printer
val to_string : t -> string
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Unsat_cert/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Unsat_cert/index.html index b11b7858..80166d4f 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-S/Unsat_cert/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-S/Unsat_cert/index.html @@ -1,2 +1,2 @@ -Unsat_cert (sidekick.Sidekick_simplex.S.Unsat_cert)

Module S.Unsat_cert

type t = unsat_cert
val lits : t -> V.lit list
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file +Unsat_cert (sidekick.Sidekick_simplex.S.Unsat_cert)

Module S.Unsat_cert

type t = unsat_cert
val lits : t -> V.lit list
val pp : t Sidekick_util.Fmt.printer
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/V/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/V/index.html index 26d2d6db..1d4a58e9 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-S/V/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-S/V/index.html @@ -1,2 +1,2 @@ -V (sidekick.Sidekick_simplex.S.V)

Module S.V

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file +V (sidekick.Sidekick_simplex.S.V)

Module S.V

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Z/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Z/index.html index de01a8f8..636fbcbc 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-S/Z/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-S/Z/index.html @@ -1,2 +1,2 @@ -Z (sidekick.Sidekick_simplex.S.Z)

Module S.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file +Z (sidekick.Sidekick_simplex.S.Z)

Module S.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/index.html index 648b91e7..be4e3fa8 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-S/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-S/index.html @@ -1,12 +1,12 @@ -S (sidekick.Sidekick_simplex.S)

Module type Sidekick_simplex.S

module V : VAR
module V_map : CCMap.S with type key = V.t
module Z : INT
module Q : RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?is_int:bool -> - on_propagate:ev_on_propagate -> +S (sidekick.Sidekick_simplex.S)

Module type Sidekick_simplex.S

module V : VAR
module V_map : CCMap.S with type key = V.t
module Z : INT
module Q : RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : + ?is_int:bool -> + on_propagate:ev_on_propagate -> t -> Constraint.t -> V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:(V.lit -> reason:V.lit list -> unit) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
  1. | Sat of Subst.t
  2. | Unsat of Unsat_cert.t
val check : on_propagate:(V.lit -> reason:V.lit list -> unit) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : - on_propagate:(V.lit -> reason:V.lit list -> unit) -> - max_tree_nodes:int -> + unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:(V.lit -> reason:V.lit list -> unit) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
  1. | Sat of Subst.t
  2. | Unsat of Unsat_cert.t
val check : on_propagate:(V.lit -> reason:V.lit list -> unit) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : + on_propagate:(V.lit -> reason:V.lit list -> unit) -> + max_tree_nodes:int -> t -> - result option

Try to solve and respect the integer constraints.

val n_vars : t -> int
val n_rows : t -> int
\ No newline at end of file + result option

Try to solve and respect the integer constraints.

val n_vars : t -> int
val n_rows : t -> int
diff --git a/dev/sidekick/Sidekick_simplify/.dummy b/dev/sidekick/Sidekick_simplify/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_simplify/index.html b/dev/sidekick/Sidekick_simplify/index.html index 89b68fcf..61434053 100644 --- a/dev/sidekick/Sidekick_simplify/index.html +++ b/dev/sidekick/Sidekick_simplify/index.html @@ -1,5 +1,5 @@ -Sidekick_simplify (sidekick.Sidekick_simplify)

Module Sidekick_simplify

Term simplifier

type t

Create a simplifier

val clear : t -> unit

Reset internal cache, etc.

val proof : t -> Sidekick_proof.Tracer.t

Access proof

type hook = +Sidekick_simplify (sidekick.Sidekick_simplify)

Module Sidekick_simplify

Term simplifier

type t

Create a simplifier

val clear : t -> unit

Reset internal cache, etc.

val proof : t -> Sidekick_proof.Tracer.t

Access proof

Given a Term.t, try to simplify it. Return None if it didn't change.

A simple example could be a hook that takes a Term.t t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.

The simplifier will take care of simplifying the resulting Term.t further, caching (so that work is not duplicated in subterms), etc.

val add_hook : t -> hook -> unit
val normalize : @@ -8,4 +8,4 @@ (Sidekick_core.Term.t * Sidekick_proof.Step.id) option

Normalize a Term.t using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the Term.t.

Normalize a Term.t using all the hooks, along with a proof that the simplification is correct. returns t, ø if no simplification occurred.

\ No newline at end of file + Sidekick_core.Term.t * Sidekick_proof.Step.id option

Normalize a Term.t using all the hooks, along with a proof that the simplification is correct. returns t, ø if no simplification occurred.

diff --git a/dev/sidekick/Sidekick_smt_solver/.dummy b/dev/sidekick/Sidekick_smt_solver/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_smt_solver/Find_foreign/index.html b/dev/sidekick/Sidekick_smt_solver/Find_foreign/index.html index 59907664..7ea21219 100644 --- a/dev/sidekick/Sidekick_smt_solver/Find_foreign/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Find_foreign/index.html @@ -1,2 +1,2 @@ -Find_foreign (sidekick.Sidekick_smt_solver.Find_foreign)

Module Sidekick_smt_solver.Find_foreign

Find foreign variables.

This module is a modular discoverer of foreign variables (and boolean terms). It should run after preprocessing of terms.

module type ACTIONS = sig ... end
type actions = (module ACTIONS)
type t
type hook = actions -> is_sub:bool -> Sidekick_core.Term.t -> unit
val create : unit -> t
val add_hook : t -> hook -> unit

Register a hook to detect foreign subterms

val traverse_term : t -> actions -> Sidekick_core.Term.t -> unit

Traverse subterms of this term to detect foreign variables and boolean subterms.

\ No newline at end of file +Find_foreign (sidekick.Sidekick_smt_solver.Find_foreign)

Module Sidekick_smt_solver.Find_foreign

Find foreign variables.

This module is a modular discoverer of foreign variables (and boolean terms). It should run after preprocessing of terms.

module type ACTIONS = sig ... end
type actions = (module ACTIONS)
type t
type hook = actions -> is_sub:bool -> Sidekick_core.Term.t -> unit
val create : unit -> t
val add_hook : t -> hook -> unit

Register a hook to detect foreign subterms

val traverse_term : t -> actions -> Sidekick_core.Term.t -> unit

Traverse subterms of this term to detect foreign variables and boolean subterms.

diff --git a/dev/sidekick/Sidekick_smt_solver/Find_foreign/module-type-ACTIONS/index.html b/dev/sidekick/Sidekick_smt_solver/Find_foreign/module-type-ACTIONS/index.html index 70e3261d..56d8253d 100644 --- a/dev/sidekick/Sidekick_smt_solver/Find_foreign/module-type-ACTIONS/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Find_foreign/module-type-ACTIONS/index.html @@ -1,2 +1,2 @@ -ACTIONS (sidekick.Sidekick_smt_solver.Find_foreign.ACTIONS)

Module type Find_foreign.ACTIONS

val declare_need_th_combination : Sidekick_core.Term.t -> unit

Declare that this term is a foreign variable in some other subterm.

val add_lit_for_bool_term : ?default_pol:bool -> Sidekick_core.Term.t -> unit

Add the (boolean) term to the SAT solver

\ No newline at end of file +ACTIONS (sidekick.Sidekick_smt_solver.Find_foreign.ACTIONS)

Module type Find_foreign.ACTIONS

val declare_need_th_combination : Sidekick_core.Term.t -> unit

Declare that this term is a foreign variable in some other subterm.

val add_lit_for_bool_term : ?default_pol:bool -> Sidekick_core.Term.t -> unit

Add the (boolean) term to the SAT solver

diff --git a/dev/sidekick/Sidekick_smt_solver/Model/index.html b/dev/sidekick/Sidekick_smt_solver/Model/index.html index 0d5d534d..3d6e6657 100644 --- a/dev/sidekick/Sidekick_smt_solver/Model/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Model/index.html @@ -1,2 +1,2 @@ -Model (sidekick.Sidekick_smt_solver.Model)

Module Sidekick_smt_solver.Model

SMT models.

The solver models are partially evaluated; the frontend might ask for values for terms not explicitly present in them.

type t = {
  1. eval : Sidekick_core.Term.t -> Sigs.value option;
  2. map : Sigs.value Sidekick_smt_solver__.Sigs.Term.Map.t;
}
val is_empty : t -> bool
val eval : t -> Sidekick_core.Term.t -> Sigs.value option
val pp : Sidekick_smt_solver__.Sigs.Fmt.t -> t -> unit
\ No newline at end of file +Model (sidekick.Sidekick_smt_solver.Model)

Module Sidekick_smt_solver.Model

SMT models.

The solver models are partially evaluated; the frontend might ask for values for terms not explicitly present in them.

type t = {
  1. eval : Sidekick_core.Term.t -> Sigs.value option;
  2. map : Sigs.value Sidekick_smt_solver__.Sigs.Term.Map.t;
}
val is_empty : t -> bool
val eval : t -> Sidekick_core.Term.t -> Sigs.value option
val pp : Sidekick_smt_solver__.Sigs.Fmt.t -> t -> unit
diff --git a/dev/sidekick/Sidekick_smt_solver/Model_builder/index.html b/dev/sidekick/Sidekick_smt_solver/Model_builder/index.html index 47634f7b..53fffc83 100644 --- a/dev/sidekick/Sidekick_smt_solver/Model_builder/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Model_builder/index.html @@ -1,14 +1,14 @@ -Model_builder (sidekick.Sidekick_smt_solver.Model_builder)

Module Sidekick_smt_solver.Model_builder

Model Builder.

This contains a partial model, in construction. It is accessible to every theory, so they can contribute partial values.

TODO: seen values?

type t
include Sidekick_sigs.PRINT with type t := t
val create : Sidekick_core.Term.store -> t
val mem : t -> Sidekick_core.Term.t -> bool
val require_eval : t -> Sidekick_core.Term.t -> unit

Require that this term gets a value, and assign it to all terms in the given class.

val add : +Model_builder (sidekick.Sidekick_smt_solver.Model_builder)

Module Sidekick_smt_solver.Model_builder

Model Builder.

This contains a partial model, in construction. It is accessible to every theory, so they can contribute partial values.

TODO: seen values?

type t
include Sidekick_sigs.PRINT with type t := t
val create : Sidekick_core.Term.store -> t
val mem : t -> Sidekick_core.Term.t -> bool
val require_eval : t -> Sidekick_core.Term.t -> unit

Require that this term gets a value, and assign it to all terms in the given class.

val add : t -> - ?subs:Sidekick_core.Term.t list -> + ?subs:Sidekick_core.Term.t list -> Sidekick_core.Term.t -> Sigs.value -> - unit

Add a value to the model.

  • parameter subs

    if provided, these terms will be passed to require_eval to ensure they map to a value.

val gensym : t -> pre:string -> ty:Sidekick_core.Term.t -> Sidekick_core.Term.t

New fresh constant

type eval_cache = Sidekick_smt_solver__.Sigs.Term.Internal_.cache
val create_cache : int -> eval_cache
val eval : ?cache:eval_cache -> t -> Sidekick_core.Term.t -> Sigs.value
val eval_opt : - ?cache:eval_cache -> + unit

Add a value to the model.

  • parameter subs

    if provided, these terms will be passed to require_eval to ensure they map to a value.

val gensym : t -> pre:string -> ty:Sidekick_core.Term.t -> Sidekick_core.Term.t

New fresh constant

type eval_cache = Sidekick_smt_solver__.Sigs.Term.Internal_.cache
val create_cache : int -> eval_cache
val eval : ?cache:eval_cache -> t -> Sidekick_core.Term.t -> Sigs.value
val eval_opt : + ?cache:eval_cache -> t -> Sidekick_core.Term.t -> Sigs.value option
val pop_required : t -> Sidekick_core.Term.t option

gives the next subterm that is required but has no value yet

val to_map : - ?cache:eval_cache -> + ?cache:eval_cache -> t -> - Sigs.value Sidekick_smt_solver__.Sigs.Term.Map.t
\ No newline at end of file + Sigs.value Sidekick_smt_solver__.Sigs.Term.Map.t
diff --git a/dev/sidekick/Sidekick_smt_solver/Preprocess/index.html b/dev/sidekick/Sidekick_smt_solver/Preprocess/index.html index 6da6b9eb..52033ff6 100644 --- a/dev/sidekick/Sidekick_smt_solver/Preprocess/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Preprocess/index.html @@ -1,14 +1,14 @@ -Preprocess (sidekick.Sidekick_smt_solver.Preprocess)

Module Sidekick_smt_solver.Preprocess

Preprocessor

The preprocessor turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Every literal undergoes preprocessing. Typically some clauses are also added to the solver on the side, and some subterms are found to be foreign variables.

type t

Preprocessor

val create : - ?stat:Sidekick_util.Stat.t -> - proof:Sidekick_proof.Tracer.t -> - cc:Sidekick_cc.CC.t -> - simplify:Sidekick_simplify.t -> +Preprocess (sidekick.Sidekick_smt_solver.Preprocess)

Module Sidekick_smt_solver.Preprocess

Preprocessor

The preprocessor turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Every literal undergoes preprocessing. Typically some clauses are also added to the solver on the side, and some subterms are found to be foreign variables.

type t

Preprocessor

module type PREPROCESS_ACTS = sig ... end

Actions given to preprocessor hooks

type preprocess_actions = (module PREPROCESS_ACTS)

Actions available to the preprocessor

type preprocess_hook = t -> - is_sub:bool -> - recurse:(Sigs.term -> Sigs.term) -> + is_sub:bool -> + recurse:(Sigs.term -> Sigs.term) -> preprocess_actions -> Sigs.term -> Sigs.term option

Given a term, preprocess it.

The idea is to add literals and clauses to help define the meaning of the term, if needed. For example for boolean formulas, clauses for their Tseitin encoding can be added, with the formula acting as its own proxy symbol; or a new symbol might be added.

  • parameter preprocess_actions

    actions available during preprocessing.

val on_preprocess : t -> preprocess_hook -> unit

Add a hook that will be called when terms are preprocessed

val simplify_and_preproc_lit : @@ -25,4 +25,4 @@ preprocess_actions -> Sigs.lit array -> Sigs.step_id -> - Sigs.lit array * Sigs.step_id
val cc : t -> Sidekick_cc.CC.t
\ No newline at end of file + Sigs.lit array * Sigs.step_id
val cc : t -> Sidekick_cc.CC.t
diff --git a/dev/sidekick/Sidekick_smt_solver/Preprocess/module-type-PREPROCESS_ACTS/index.html b/dev/sidekick/Sidekick_smt_solver/Preprocess/module-type-PREPROCESS_ACTS/index.html index 016db998..d2459da1 100644 --- a/dev/sidekick/Sidekick_smt_solver/Preprocess/module-type-PREPROCESS_ACTS/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Preprocess/module-type-PREPROCESS_ACTS/index.html @@ -1,2 +1,2 @@ -PREPROCESS_ACTS (sidekick.Sidekick_smt_solver.Preprocess.PREPROCESS_ACTS)

Module type Preprocess.PREPROCESS_ACTS

Actions given to preprocessor hooks

val proof_tracer : Sidekick_proof.Tracer.t
val mk_lit : ?sign:bool -> Sigs.term -> Sigs.lit

mk_lit t creates a new literal for a boolean term t.

val add_clause : Sigs.lit list -> Sigs.step_id -> unit

pushes a new clause into the SAT solver.

val add_lit : ?default_pol:bool -> Sigs.lit -> unit

Ensure the literal will be decided/handled by the SAT solver.

\ No newline at end of file +PREPROCESS_ACTS (sidekick.Sidekick_smt_solver.Preprocess.PREPROCESS_ACTS)

Module type Preprocess.PREPROCESS_ACTS

Actions given to preprocessor hooks

val proof_tracer : Sidekick_proof.Tracer.t
val mk_lit : ?sign:bool -> Sigs.term -> Sigs.lit

mk_lit t creates a new literal for a boolean term t.

val add_clause : Sigs.lit list -> Sigs.step_id -> unit

pushes a new clause into the SAT solver.

val add_lit : ?default_pol:bool -> Sigs.lit -> unit

Ensure the literal will be decided/handled by the SAT solver.

diff --git a/dev/sidekick/Sidekick_smt_solver/Registry/index.html b/dev/sidekick/Sidekick_smt_solver/Registry/index.html index fe5561c7..880514db 100644 --- a/dev/sidekick/Sidekick_smt_solver/Registry/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Registry/index.html @@ -1,2 +1,2 @@ -Registry (sidekick.Sidekick_smt_solver.Registry)

Module Sidekick_smt_solver.Registry

Registry to extract values

type t
type 'a key
val create_key : unit -> 'a key

Call this statically, typically at program initialization, for each distinct key.

val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file +Registry (sidekick.Sidekick_smt_solver.Registry)

Module Sidekick_smt_solver.Registry

Registry to extract values

type t
type 'a key
val create_key : unit -> 'a key

Call this statically, typically at program initialization, for each distinct key.

val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
diff --git a/dev/sidekick/Sidekick_smt_solver/Sigs/index.html b/dev/sidekick/Sidekick_smt_solver/Sigs/index.html index 7e0e52e7..3ca6817d 100644 --- a/dev/sidekick/Sidekick_smt_solver/Sigs/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Sigs/index.html @@ -1,7 +1,7 @@ -Sigs (sidekick.Sidekick_smt_solver.Sigs)

Module Sidekick_smt_solver.Sigs

Signature for the main SMT solver types.

Theories and concrete solvers rely on an environment that defines several important types:

  • sorts
  • terms (to represent logic expressions and formulas)
  • a congruence closure instance
  • a bridge to some SAT solver

In this module we collect signatures defined elsewhere and define the module types for the main SMT solver.

include module type of struct include Sidekick_core end
module Fmt = Sidekick_core.Fmt

Re-exports from core-logic

module Const = Sidekick_core.Const
module Str_const = Sidekick_core.Str_const
module Term = Sidekick_core.Term

view

module Bool_view = Sidekick_core.Bool_view
module CC_view = Sidekick_core.CC_view
module Default_cc_view = Sidekick_core.Default_cc_view

Main modules

module Bvar = Sidekick_core.Bvar
module Lit = Sidekick_core.Lit
module Subst = Sidekick_core.Subst
module Var = Sidekick_core.Var
module Box = Sidekick_core.Box
module Gensym = Sidekick_core.Gensym
exception Resource_exhausted

Const decoders for traces

val const_decoders : +Sigs (sidekick.Sidekick_smt_solver.Sigs)

Module Sidekick_smt_solver.Sigs

Signature for the main SMT solver types.

Theories and concrete solvers rely on an environment that defines several important types:

  • sorts
  • terms (to represent logic expressions and formulas)
  • a congruence closure instance
  • a bridge to some SAT solver

In this module we collect signatures defined elsewhere and define the module types for the main SMT solver.

include module type of struct include Sidekick_core end
module Fmt = Sidekick_core.Fmt

Re-exports from core-logic

module Const = Sidekick_core.Const
module Str_const = Sidekick_core.Str_const
module Term = Sidekick_core.Term

view

module Bool_view = Sidekick_core.Bool_view
module CC_view = Sidekick_core.CC_view
module Default_cc_view = Sidekick_core.Default_cc_view

Main modules

module Bvar = Sidekick_core.Bvar
module Lit = Sidekick_core.Lit
module Subst = Sidekick_core.Subst
module Var = Sidekick_core.Var
module Box = Sidekick_core.Box
module Gensym = Sidekick_core.Gensym
exception Resource_exhausted

Const decoders for traces

val const_decoders : (string * Sidekick_core_logic.Const.Ops.t * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t -> Sidekick_core_logic.Const.view Sidekick_util.Ser_decode.t)) - list
module Simplify = Sidekick_simplify
module CC = Sidekick_cc.CC
module E_node = Sidekick_cc.E_node
module CC_expl = Sidekick_cc.Expl
module Proof = Sidekick_proof
type term = Term.t
type ty = term
type value = Term.t
type lit = Lit.t
type term_store = Term.store
type step_id = Sidekick_proof.Step.id
type sat_acts = Sidekick_sat.acts
type th_combination_conflict = {
  1. lits : lit list;
  2. semantic : (bool * term * term) list;
}

Conflict obtained during theory combination. It involves equalities merged because of the current model so it's not a "true" conflict and doesn't need to kill the current trail.

module type ARG = sig ... end

Argument to pass to the functor Make in order to create a new Msat-based SMT solver.

\ No newline at end of file + list
module Simplify = Sidekick_simplify
module CC = Sidekick_cc.CC
module E_node = Sidekick_cc.E_node
module CC_expl = Sidekick_cc.Expl
module Proof = Sidekick_proof
type term = Term.t
type ty = term
type value = Term.t
type lit = Lit.t
type term_store = Term.store
type step_id = Sidekick_proof.Step.id
type sat_acts = Sidekick_sat.acts
type th_combination_conflict = {
  1. lits : lit list;
  2. semantic : (bool * term * term) list;
}

Conflict obtained during theory combination. It involves equalities merged because of the current model so it's not a "true" conflict and doesn't need to kill the current trail.

module type ARG = sig ... end

Argument to pass to the functor Make in order to create a new Msat-based SMT solver.

diff --git a/dev/sidekick/Sidekick_smt_solver/Sigs/module-type-ARG/index.html b/dev/sidekick/Sidekick_smt_solver/Sigs/module-type-ARG/index.html index 7de75cb0..94142939 100644 --- a/dev/sidekick/Sidekick_smt_solver/Sigs/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Sigs/module-type-ARG/index.html @@ -1,2 +1,2 @@ -ARG (sidekick.Sidekick_smt_solver.Sigs.ARG)

Module type Sigs.ARG

Argument to pass to the functor Make in order to create a new Msat-based SMT solver.

val view_as_cc : Sidekick_cc.view_as_cc
\ No newline at end of file +ARG (sidekick.Sidekick_smt_solver.Sigs.ARG)

Module type Sigs.ARG

Argument to pass to the functor Make in order to create a new Msat-based SMT solver.

val view_as_cc : Sidekick_cc.view_as_cc
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver/index.html b/dev/sidekick/Sidekick_smt_solver/Solver/index.html index 63c33f2d..e50807b6 100644 --- a/dev/sidekick/Sidekick_smt_solver/Solver/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Solver/index.html @@ -1,32 +1,32 @@ -Solver (sidekick.Sidekick_smt_solver.Solver)

Module Sidekick_smt_solver.Solver

Main solver type, user facing.

This is the solver a user of sidekick can see, after instantiating everything. The user can add some theories, clauses, etc. and asks the solver to check satisfiability.

Theory implementors will mostly interact with SOLVER_INTERNAL.

type t

The solver's state.

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

type theory = Theory.t
val mk_theory : - name:string -> - create_and_setup:(id:Theory_id.t -> Solver_internal.t -> 'th) -> - ?push_level:('th -> unit) -> - ?pop_levels:('th -> int -> unit) -> +Solver (sidekick.Sidekick_smt_solver.Solver)

Module Sidekick_smt_solver.Solver

Main solver type, user facing.

This is the solver a user of sidekick can see, after instantiating everything. The user can add some theories, clauses, etc. and asks the solver to check satisfiability.

Theory implementors will mostly interact with SOLVER_INTERNAL.

type t

The solver's state.

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

type theory = Theory.t
val mk_theory : + name:string -> + create_and_setup:(id:Theory_id.t -> Solver_internal.t -> 'th) -> + ?push_level:('th -> unit) -> + ?pop_levels:('th -> int -> unit) -> unit -> Theory.t

Helper to create a theory.

Main API

val stats : t -> Sidekick_util.Stat.t
val tracer : t -> Tracer.t
val create : (module Sigs.ARG) -> - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Big | `Tiny | `Small ] -> - tracer:Tracer.t -> - theories:Theory.t list -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Big | `Tiny | `Small ] -> + tracer:Tracer.t -> + theories:Theory.t list -> Sidekick_core.Term.store -> unit -> t

Create a new solver.

It needs a term state and a type state to manipulate terms and types. All terms and types interacting with this solver will need to come from these exact states.

  • parameter store_proof

    if true, proofs from the SAT solver and theories are retained and potentially accessible after solve returns UNSAT.

  • parameter size

    influences the size of initial allocations.

  • parameter theories

    theories to load from the start. Other theories can be added using add_theory.

val create_default : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Big | `Tiny | `Small ] -> - tracer:Tracer.t -> - theories:Theory.t list -> + ?stat:Sidekick_util.Stat.t -> + ?size:[ `Big | `Tiny | `Small ] -> + tracer:Tracer.t -> + theories:Theory.t list -> Sidekick_core.Term.store -> unit -> - t

Create a new solver with the default CC view, and where all boolean subterms are mapped to boolean atoms.

val add_theory : t -> Theory.t -> unit

Add a theory to the solver. This should be called before any call to solve or to add_clause and the likes (otherwise the theory will have a partial view of the problem).

val add_theory_p : t -> 'a Theory.p -> 'a

Add the given theory and obtain its state

val add_theory_l : t -> Theory.t list -> unit
val mk_lit_t : t -> ?sign:bool -> Sigs.term -> Sigs.lit

mk_lit_t _ ~sign t returns lit', where lit' is preprocess(lit) and lit is an internal representation of ± t.

The proof of |- lit = lit' is directly added to the solver's proof.

val add_clause : t -> Sigs.lit array -> Sidekick_proof.Pterm.delayed -> unit

add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.

val add_clause_l : t -> Sigs.lit list -> Sidekick_proof.Pterm.delayed -> unit

Add a clause to the solver, given as a list.

val assert_terms : t -> Sigs.term list -> unit

Helper that turns each term into an atom, before adding disjunction of the resulting atoms to the solver as a clause assertion

val assert_term : t -> Sigs.term -> unit

Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion

val add_ty : t -> Sigs.ty -> unit
type sat_result = Check_res.sat_result = {
  1. get_value : Sidekick_core.Term.t -> value option;
    (*

    Value for this term

    *)
  2. iter_classes : (Sidekick_core.Term.t Iter.t * value) Iter.t;
    (*

    All equivalence classes in the congruence closure

    *)
  3. eval_lit : Sidekick_core.Lit.t -> bool option;
    (*

    Evaluate literal

    *)
  4. iter_true_lits : Sidekick_core.Lit.t Iter.t;
    (*

    Iterate on literals that are true in the trail

    *)
}

Satisfiable

type unsat_result = Check_res.unsat_result = {
  1. unsat_core : unit -> Sidekick_core.Lit.t Iter.t;
    (*

    Unsat core (subset of assumptions), or empty

    *)
  2. unsat_proof : unit -> Sidekick_proof.Step.id option;
    (*

    Proof step for the empty clause

    *)
}

Unsatisfiable

type res = Check_res.t =
  1. | Sat of sat_result
  2. | Unsat of unsat_result
  3. | Unknown of Unknown.t
    (*

    Unknown, obtained after a timeout, memory limit, etc.

    *)

Result of solving for the current set of clauses

val solve : - ?on_exit:(unit -> unit) list -> - ?on_progress:(unit -> unit) -> - ?should_stop:(int -> bool) -> - assumptions:Sigs.lit list -> + t

Create a new solver with the default CC view, and where all boolean subterms are mapped to boolean atoms.

val add_theory : t -> Theory.t -> unit

Add a theory to the solver. This should be called before any call to solve or to add_clause and the likes (otherwise the theory will have a partial view of the problem).

val add_theory_p : t -> 'a Theory.p -> 'a

Add the given theory and obtain its state

val add_theory_l : t -> Theory.t list -> unit
val mk_lit_t : t -> ?sign:bool -> Sigs.term -> Sigs.lit

mk_lit_t _ ~sign t returns lit', where lit' is preprocess(lit) and lit is an internal representation of ± t.

The proof of |- lit = lit' is directly added to the solver's proof.

val add_clause : t -> Sigs.lit array -> Sidekick_proof.Pterm.delayed -> unit

add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.

val add_clause_l : t -> Sigs.lit list -> Sidekick_proof.Pterm.delayed -> unit

Add a clause to the solver, given as a list.

val assert_terms : t -> Sigs.term list -> unit

Helper that turns each term into an atom, before adding disjunction of the resulting atoms to the solver as a clause assertion

val assert_term : t -> Sigs.term -> unit

Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion

val add_ty : t -> Sigs.ty -> unit
type sat_result = Check_res.sat_result = {
  1. get_value : Sidekick_core.Term.t -> value option;
    (*

    Value for this term

    *)
  2. iter_classes : (Sidekick_core.Term.t Iter.t * value) Iter.t;
    (*

    All equivalence classes in the congruence closure

    *)
  3. eval_lit : Sidekick_core.Lit.t -> bool option;
    (*

    Evaluate literal

    *)
  4. iter_true_lits : Sidekick_core.Lit.t Iter.t;
    (*

    Iterate on literals that are true in the trail

    *)
}

Satisfiable

type unsat_result = Check_res.unsat_result = {
  1. unsat_core : unit -> Sidekick_core.Lit.t Iter.t;
    (*

    Unsat core (subset of assumptions), or empty

    *)
  2. unsat_proof : unit -> Sidekick_proof.Step.id option;
    (*

    Proof step for the empty clause

    *)
}

Unsatisfiable

type res = Check_res.t =
  1. | Sat of sat_result
  2. | Unsat of unsat_result
  3. | Unknown of Unknown.t
    (*

    Unknown, obtained after a timeout, memory limit, etc.

    *)

Result of solving for the current set of clauses

val solve : + ?on_exit:(unit -> unit) list -> + ?on_progress:(unit -> unit) -> + ?should_stop:(int -> bool) -> + assumptions:Sigs.lit list -> t -> res

solve s checks the satisfiability of the clauses added so far to s.

  • parameter on_progress

    called regularly during solving.

  • parameter assumptions

    a set of atoms held to be true. The unsat core, if any, will be a subset of assumptions.

  • parameter should_stop

    a callback regularly called from within the solver. It is given a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

Comply to the abstract solver interface

val last_res : t -> res option

Last result, if any. Some operations will erase this (e.g. assert_term).

val push_assumption : t -> Sigs.lit -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions. Note that check_sat_propagations_only can call this if it meets a conflict.

type propagation_result =
  1. | PR_sat
  2. | PR_conflict of {
    1. backtracked : int;
    }
  3. | PR_unsat of {
    1. unsat_core : unit -> Sigs.lit Iter.t;
    }
val check_sat_propagations_only : - assumptions:Sigs.lit list -> + assumptions:Sigs.lit list -> t -> - propagation_result

check_sat_propagations_only solver uses assumptions (including the assumptions parameter, and atoms previously added via push_assumptions) and boolean+theory propagation to quickly assess satisfiability. It is not complete; calling solve is required to get an accurate result.

  • returns

    one of:

    • PR_sat if the current state seems satisfiable
    • PR_conflict {backtracked=n} if a conflict was found and resolved, leading to backtracking n levels of assumptions
    • PR_unsat … if the assumptions were found to be unsatisfiable, with the given core.
val pp_stats : t CCFormat.printer

Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file + propagation_result

check_sat_propagations_only solver uses assumptions (including the assumptions parameter, and atoms previously added via push_assumptions) and boolean+theory propagation to quickly assess satisfiability. It is not complete; calling solve is required to get an accurate result.

  • returns

    one of:

    • PR_sat if the current state seems satisfiable
    • PR_conflict {backtracked=n} if a conflict was found and resolved, leading to backtracking n levels of assumptions
    • PR_unsat … if the assumptions were found to be unsatisfiable, with the given core.
val pp_stats : t CCFormat.printer

Print some statistics. What it prints exactly is unspecified.

diff --git a/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/argument-1-A/index.html b/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/argument-1-A/index.html index f4a4df1f..a7fd243a 100644 --- a/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/argument-1-A/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/argument-1-A/index.html @@ -1,8 +1,8 @@ -A (sidekick.Sidekick_smt_solver.Solver_internal.Perform_delayed.A)

Parameter Perform_delayed.A

type t
val add_clause : +A (sidekick.Sidekick_smt_solver.Solver_internal.Perform_delayed.A)

Parameter Perform_delayed.A

type t
val add_clause : solver -> t -> - keep:bool -> + keep:bool -> Sigs.lit list -> Sigs.step_id -> - unit
val add_lit : solver -> t -> ?default_pol:bool -> Sigs.lit -> unit
\ No newline at end of file + unit
val add_lit : solver -> t -> ?default_pol:bool -> Sigs.lit -> unit
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/index.html b/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/index.html index c587d52d..5ee4b1b5 100644 --- a/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/index.html @@ -1,2 +1,2 @@ -Perform_delayed (sidekick.Sidekick_smt_solver.Solver_internal.Perform_delayed)

Module Solver_internal.Perform_delayed

Parameters

module A : PERFORM_ACTS

Signature

val top : t -> A.t -> unit
\ No newline at end of file +Perform_delayed (sidekick.Sidekick_smt_solver.Solver_internal.Perform_delayed)

Module Solver_internal.Perform_delayed

Parameters

module A : PERFORM_ACTS

Signature

val top : t -> A.t -> unit
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver_internal/index.html b/dev/sidekick/Sidekick_smt_solver/Solver_internal/index.html index 3bbd543b..4dd9c9c5 100644 --- a/dev/sidekick/Sidekick_smt_solver/Solver_internal/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Solver_internal/index.html @@ -1,8 +1,8 @@ -Solver_internal (sidekick.Sidekick_smt_solver.Solver_internal)

Module Sidekick_smt_solver.Solver_internal

A view of the solver from a theory's point of view.

Theories should interact with the solver via this module, to assert new lemmas, propagate literals, access the congruence closure, etc.

type t

Main type for the SMT solver

type solver = t
val tst : t -> Sigs.term_store
val stats : t -> Sidekick_util.Stat.t
val tracer : t -> Tracer.t

Access the tracer object

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

Actions for the theories

type theory_actions

Handle that the theories can use to perform actions.

Congruence Closure

val cc : t -> Sidekick_cc.CC.t

Congruence closure for this solver

Backtracking

include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int

Number of levels

val push_level : t -> unit

Push a backtracking point

val pop_levels : t -> int -> unit

pop_levels st n removes n levels

Interface to SAT

val to_sat_plugin : t -> (module Sidekick_sat.PLUGIN)

Simplifiers

type simplify_hook = Sidekick_simplify.hook
val simplifier : t -> Sidekick_simplify.t
val add_simplifier : t -> Sidekick_simplify.hook -> unit

Add a simplifier hook for preprocessing.

val simplify_t : t -> Sigs.term -> (Sigs.term * Sigs.step_id) option

Simplify input term, returns Some u if some simplification occurred.

val simp_t : t -> Sigs.term -> Sigs.term * Sigs.step_id option

simp_t si t returns u even if no simplification occurred (in which case t == u syntactically). It emits |- t=u. (see simplifier)

Preprocessors

These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.

module type PREPROCESS_ACTS = Preprocess.PREPROCESS_ACTS
type preprocess_actions = (module PREPROCESS_ACTS)

Actions available to the preprocessor

type preprocess_hook = +Solver_internal (sidekick.Sidekick_smt_solver.Solver_internal)

Module Sidekick_smt_solver.Solver_internal

A view of the solver from a theory's point of view.

Theories should interact with the solver via this module, to assert new lemmas, propagate literals, access the congruence closure, etc.

type t

Main type for the SMT solver

type solver = t
val tst : t -> Sigs.term_store
val stats : t -> Sidekick_util.Stat.t
val tracer : t -> Tracer.t

Access the tracer object

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

Actions for the theories

type theory_actions

Handle that the theories can use to perform actions.

Congruence Closure

val cc : t -> Sidekick_cc.CC.t

Congruence closure for this solver

Backtracking

include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int

Number of levels

val push_level : t -> unit

Push a backtracking point

val pop_levels : t -> int -> unit

pop_levels st n removes n levels

Interface to SAT

val to_sat_plugin : t -> (module Sidekick_sat.PLUGIN)

Simplifiers

type simplify_hook = Sidekick_simplify.hook
val simplifier : t -> Sidekick_simplify.t
val add_simplifier : t -> Sidekick_simplify.hook -> unit

Add a simplifier hook for preprocessing.

val simplify_t : t -> Sigs.term -> (Sigs.term * Sigs.step_id) option

Simplify input term, returns Some u if some simplification occurred.

val simp_t : t -> Sigs.term -> Sigs.term * Sigs.step_id option

simp_t si t returns u even if no simplification occurred (in which case t == u syntactically). It emits |- t=u. (see simplifier)

Preprocessors

These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.

module type PREPROCESS_ACTS = Preprocess.PREPROCESS_ACTS
type preprocess_actions = (module PREPROCESS_ACTS)

Actions available to the preprocessor

type preprocess_hook = Preprocess.t -> - is_sub:bool -> - recurse:(Sigs.term -> Sigs.term) -> + is_sub:bool -> + recurse:(Sigs.term -> Sigs.term) -> preprocess_actions -> Sigs.term -> Sigs.term option

Given a term, preprocess it.

The idea is to add literals and clauses to help define the meaning of the term, if needed. For example for boolean formulas, clauses for their Tseitin encoding can be added, with the formula acting as its own proxy symbol.

  • parameter preprocess_actions

    actions available during preprocessing.

val preprocess : t -> Preprocess.t
val on_preprocess : t -> preprocess_hook -> unit

Add a hook that will be called when terms are preprocessed

val preprocess_clause : @@ -22,7 +22,7 @@ t -> theory_actions -> Sigs.lit -> - reason:(unit -> Sigs.lit list * Sidekick_proof.Pterm.delayed) -> + reason:(unit -> Sigs.lit list * Sidekick_proof.Pterm.delayed) -> unit

Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology

val propagate_l : t -> theory_actions -> @@ -39,7 +39,7 @@ theory_actions -> Sigs.lit list -> Sidekick_proof.Pterm.delayed -> - unit

Add toplevel clause to the SAT solver. This clause will not be backtracked.

val add_ty : t -> ty:Sigs.term -> unit

Declare a sort for the SMT solver

val mk_lit : t -> ?sign:bool -> Sigs.term -> Sigs.lit

Create a literal. This automatically preprocesses the term.

val add_lit : t -> theory_actions -> ?default_pol:bool -> Sigs.lit -> unit

Add the given literal to the SAT solver, so it gets assigned a boolean value.

  • parameter default_pol

    default polarity for the corresponding atom

val add_lit_t : t -> theory_actions -> ?sign:bool -> Sigs.term -> unit

Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value

Find representative of the node

val cc_are_equal : t -> Sigs.term -> Sigs.term -> bool

Are these two terms equal in the congruence closure?

val cc_resolve_expl : + unit

Add toplevel clause to the SAT solver. This clause will not be backtracked.

val add_ty : t -> ty:Sigs.term -> unit

Declare a sort for the SMT solver

val mk_lit : t -> ?sign:bool -> Sigs.term -> Sigs.lit

Create a literal. This automatically preprocesses the term.

val add_lit : t -> theory_actions -> ?default_pol:bool -> Sigs.lit -> unit

Add the given literal to the SAT solver, so it gets assigned a boolean value.

  • parameter default_pol

    default polarity for the corresponding atom

val add_lit_t : t -> theory_actions -> ?sign:bool -> Sigs.term -> unit

Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value

Find representative of the node

val cc_are_equal : t -> Sigs.term -> Sigs.term -> bool

Are these two terms equal in the congruence closure?

val cc_resolve_expl : t -> Sidekick_cc.Expl.t -> Sigs.lit list * Sidekick_proof.Pterm.delayed
val cc_add_term : t -> Sigs.term -> Sidekick_cc.E_node.t

Add/retrieve congruence closure node for this term. To be used in theories

val cc_mem_term : t -> Sigs.term -> bool

Return true if the term is explicitly in the congruence closure. To be used in theories

val on_cc_pre_merge : @@ -78,19 +78,19 @@ t -> Model_builder.t -> Sidekick_core.Term.t -> - (Sigs.value * Sidekick_core.Term.t list) option

A model-production hook to query values from a theory.

It takes the solver, a class, and returns an optional value for this class (potentially with sub-terms to find values for, if the value is actually a skeleton).

For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value. The theory of arrays might return array.const $v for an array Array A B, where $v will be picked by the theory of the sort B.

If no hook assigns a value to a class, a fake value is created for it.

type model_completion_hook = t -> add:(Sigs.term -> Sigs.value -> unit) -> unit

A model production hook, for the theory to add values. The hook is given a add function to add bindings to the model.

val on_model : - ?ask:model_ask_hook -> - ?complete:model_completion_hook -> + (Sigs.value * Sidekick_core.Term.t list) option

A model-production hook to query values from a theory.

It takes the solver, a class, and returns an optional value for this class (potentially with sub-terms to find values for, if the value is actually a skeleton).

For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value. The theory of arrays might return array.const $v for an array Array A B, where $v will be picked by the theory of the sort B.

If no hook assigns a value to a class, a fake value is created for it.

type model_completion_hook = t -> add:(Sigs.term -> Sigs.value -> unit) -> unit

A model production hook, for the theory to add values. The hook is given a add function to add bindings to the model.

val on_model : + ?ask:model_ask_hook -> + ?complete:model_completion_hook -> t -> unit

Add model production/completion hooks.

val on_progress : t -> (unit, unit) Sidekick_util.Event.t
val is_complete : t -> bool

Are we still in a complete logic fragment?

val last_model : t -> Model.t option

Delayed actions

module type PERFORM_ACTS = sig ... end
module Perform_delayed (A : PERFORM_ACTS) : sig ... end
val add_theory_state : - st:'a -> - push_level:('a -> unit) -> - pop_levels:('a -> int -> unit) -> + st:'a -> + push_level:('a -> unit) -> + pop_levels:('a -> int -> unit) -> t -> unit
val create : (module Sigs.ARG) -> - stat:Sidekick_util.Stat.t -> - tracer:Tracer.t -> + stat:Sidekick_util.Stat.t -> + tracer:Tracer.t -> Sidekick_core.Term.store -> unit -> - t
\ No newline at end of file + t
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver_internal/module-type-PERFORM_ACTS/index.html b/dev/sidekick/Sidekick_smt_solver/Solver_internal/module-type-PERFORM_ACTS/index.html index ebe4901b..1e6a3dcb 100644 --- a/dev/sidekick/Sidekick_smt_solver/Solver_internal/module-type-PERFORM_ACTS/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Solver_internal/module-type-PERFORM_ACTS/index.html @@ -1,8 +1,8 @@ -PERFORM_ACTS (sidekick.Sidekick_smt_solver.Solver_internal.PERFORM_ACTS)

Module type Solver_internal.PERFORM_ACTS

type t
val add_clause : +PERFORM_ACTS (sidekick.Sidekick_smt_solver.Solver_internal.PERFORM_ACTS)

Module type Solver_internal.PERFORM_ACTS

type t
val add_clause : solver -> t -> - keep:bool -> + keep:bool -> Sigs.lit list -> Sigs.step_id -> - unit
val add_lit : solver -> t -> ?default_pol:bool -> Sigs.lit -> unit
\ No newline at end of file + unit
val add_lit : solver -> t -> ?default_pol:bool -> Sigs.lit -> unit
diff --git a/dev/sidekick/Sidekick_smt_solver/Theory/index.html b/dev/sidekick/Sidekick_smt_solver/Theory/index.html index 3771a346..6fabf709 100644 --- a/dev/sidekick/Sidekick_smt_solver/Theory/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Theory/index.html @@ -1,8 +1,8 @@ -Theory (sidekick.Sidekick_smt_solver.Theory)

Module Sidekick_smt_solver.Theory

Signatures for theory plugins

module type S = sig ... end

A theory

type t = (module S)

A theory that can be used for this particular solver.

type 'a p = (module S with type t = 'a)

A theory that can be used for this particular solver, with state of type 'a.

val name : t -> string

Name of the theory

val make : - name:string -> - create_and_setup:(id:Theory_id.t -> Solver_internal.t -> 'st) -> - ?push_level:('st0 -> unit) -> - ?pop_levels:('st1 -> int -> unit) -> +Theory (sidekick.Sidekick_smt_solver.Theory)

Module Sidekick_smt_solver.Theory

Signatures for theory plugins

module type S = sig ... end

A theory

type t = (module S)

A theory that can be used for this particular solver.

type 'a p = (module S with type t = 'a)

A theory that can be used for this particular solver, with state of type 'a.

val name : t -> string

Name of the theory

val make : + name:string -> + create_and_setup:(id:Theory_id.t -> Solver_internal.t -> 'st) -> + ?push_level:('st0 -> unit) -> + ?pop_levels:('st1 -> int -> unit) -> unit -> - t
\ No newline at end of file + t
diff --git a/dev/sidekick/Sidekick_smt_solver/Theory/module-type-S/index.html b/dev/sidekick/Sidekick_smt_solver/Theory/module-type-S/index.html index ac79b79c..2b876bd5 100644 --- a/dev/sidekick/Sidekick_smt_solver/Theory/module-type-S/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Theory/module-type-S/index.html @@ -1,2 +1,2 @@ -S (sidekick.Sidekick_smt_solver.Theory.S)

Module type Theory.S

A theory

Theories are abstracted over the concrete implementation of the solver, so they can work with any implementation.

Typically a theory should be a functor taking an argument containing a SOLVER_INTERNAL or even a full SOLVER, and some additional views on terms, literals, etc. that are specific to the theory (e.g. to map terms to linear expressions). The theory can then be instantiated on any kind of solver for any term representation that also satisfies the additional theory-specific requirements. Instantiated theories (ie values of type SOLVER.theory) can be added to the solver.

type t
val name : string
val create_and_setup : id:Theory_id.t -> Solver_internal.t -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit
\ No newline at end of file +S (sidekick.Sidekick_smt_solver.Theory.S)

Module type Theory.S

A theory

Theories are abstracted over the concrete implementation of the solver, so they can work with any implementation.

Typically a theory should be a functor taking an argument containing a SOLVER_INTERNAL or even a full SOLVER, and some additional views on terms, literals, etc. that are specific to the theory (e.g. to map terms to linear expressions). The theory can then be instantiated on any kind of solver for any term representation that also satisfies the additional theory-specific requirements. Instantiated theories (ie values of type SOLVER.theory) can be added to the solver.

type t
val name : string
val create_and_setup : id:Theory_id.t -> Solver_internal.t -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit
diff --git a/dev/sidekick/Sidekick_smt_solver/Theory_id/index.html b/dev/sidekick/Sidekick_smt_solver/Theory_id/index.html index f1e5413d..6face3a4 100644 --- a/dev/sidekick/Sidekick_smt_solver/Theory_id/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Theory_id/index.html @@ -1,2 +1,2 @@ -Theory_id (sidekick.Sidekick_smt_solver.Theory_id)

Module Sidekick_smt_solver.Theory_id

type t = private int
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
type state
val create : unit -> state
val fresh : state -> t
module Set : CCSet.S with type elt = t
\ No newline at end of file +Theory_id (sidekick.Sidekick_smt_solver.Theory_id)

Module Sidekick_smt_solver.Theory_id

type t = private int
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
type state
val create : unit -> state
val fresh : state -> t
module Set : CCSet.S with type elt = t
diff --git a/dev/sidekick/Sidekick_smt_solver/Trace_reader/index.html b/dev/sidekick/Sidekick_smt_solver/Trace_reader/index.html index 9fac32be..8ed95c38 100644 --- a/dev/sidekick/Sidekick_smt_solver/Trace_reader/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Trace_reader/index.html @@ -1,6 +1,6 @@ -Trace_reader (sidekick.Sidekick_smt_solver.Trace_reader)

Module Sidekick_smt_solver.Trace_reader

Read trace

module Proof = Sidekick_proof
module Tr = Sidekick_trace
type entry =
  1. | Assert of Sidekick_core.Term.t
  2. | Assert_clause of {
    1. id : int;
    2. c : Sidekick_core.Lit.t list;
    3. p : Proof.Pterm.t option;
    }
val pp_entry : entry Sidekick_core.Fmt.printer
type t
val create : - ?const_decoders:Sidekick_core.Const.decoders list -> +Trace_reader (sidekick.Sidekick_smt_solver.Trace_reader)

Module Sidekick_smt_solver.Trace_reader

Read trace

module Proof = Sidekick_proof
module Tr = Sidekick_trace
type entry =
  1. | Assert of Sidekick_core.Term.t
  2. | Assert_clause of {
    1. id : int;
    2. c : Sidekick_core.Lit.t list;
    3. p : Proof.Pterm.t option;
    }
val pp_entry : entry Sidekick_core.Fmt.printer
type t
val create : + ?const_decoders:Sidekick_core.Const.decoders list -> Sidekick_core.Term.store -> Tr.Source.t -> - t
val add_const_decoders : t -> Sidekick_core.Const.decoders -> unit
val term_trace_reader : t -> Sidekick_core.Term.Trace_reader.t
val decode : t -> tag:string -> Sidekick_util.Ser_value.t -> entry option
val decode_entry : t -> Tr.Entry_id.t -> entry option
\ No newline at end of file + t
val add_const_decoders : t -> Sidekick_core.Const.decoders -> unit
val term_trace_reader : t -> Sidekick_core.Term.Trace_reader.t
val decode : t -> tag:string -> Sidekick_util.Ser_value.t -> entry option
val decode_entry : t -> Tr.Entry_id.t -> entry option
diff --git a/dev/sidekick/Sidekick_smt_solver/Tracer/class-concrete/index.html b/dev/sidekick/Sidekick_smt_solver/Tracer/class-concrete/index.html index 3e060994..e1e846af 100644 --- a/dev/sidekick/Sidekick_smt_solver/Tracer/class-concrete/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Tracer/class-concrete/index.html @@ -1,2 +1,2 @@ -concrete (sidekick.Sidekick_smt_solver.Tracer.concrete)

Class Tracer.concrete

Tracer emitting to a sink

inherit Sidekick_core.Term.Tracer.t
inherit Sidekick_sat.Tracer.t
inherit Sidekick_proof.Tracer.t
method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t

Emit an assertion

\ No newline at end of file +concrete (sidekick.Sidekick_smt_solver.Tracer.concrete)

Class Tracer.concrete

Tracer emitting to a sink

inherit Sidekick_core.Term.Tracer.t
inherit Sidekick_sat.Tracer.t
inherit Sidekick_proof.Tracer.t
method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t

Emit an assertion

diff --git a/dev/sidekick/Sidekick_smt_solver/Tracer/class-dummy/index.html b/dev/sidekick/Sidekick_smt_solver/Tracer/class-dummy/index.html index 6dc2240f..b200772b 100644 --- a/dev/sidekick/Sidekick_smt_solver/Tracer/class-dummy/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Tracer/class-dummy/index.html @@ -1,2 +1,2 @@ -dummy (sidekick.Sidekick_smt_solver.Tracer.dummy)

Class Tracer.dummy

Dummy tracer

inherit Sidekick_core.Term.Tracer.t
inherit Sidekick_sat.Tracer.t
inherit Sidekick_proof.Tracer.t
method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t

Emit an assertion

\ No newline at end of file +dummy (sidekick.Sidekick_smt_solver.Tracer.dummy)

Class Tracer.dummy

Dummy tracer

inherit Sidekick_core.Term.Tracer.t
inherit Sidekick_sat.Tracer.t
inherit Sidekick_proof.Tracer.t
method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t

Emit an assertion

diff --git a/dev/sidekick/Sidekick_smt_solver/Tracer/class-type-t/index.html b/dev/sidekick/Sidekick_smt_solver/Tracer/class-type-t/index.html index 1e757cdd..240dbe9b 100644 --- a/dev/sidekick/Sidekick_smt_solver/Tracer/class-type-t/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Tracer/class-type-t/index.html @@ -1,2 +1,2 @@ -t (sidekick.Sidekick_smt_solver.Tracer.t)

Class type Tracer.t

inherit Sidekick_core.Term.Tracer.t
inherit Sidekick_sat.Tracer.t
inherit Sidekick_proof.Tracer.t
method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t

Emit an assertion

\ No newline at end of file +t (sidekick.Sidekick_smt_solver.Tracer.t)

Class type Tracer.t

inherit Sidekick_core.Term.Tracer.t
inherit Sidekick_sat.Tracer.t
inherit Sidekick_proof.Tracer.t
method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t

Emit an assertion

diff --git a/dev/sidekick/Sidekick_smt_solver/Tracer/index.html b/dev/sidekick/Sidekick_smt_solver/Tracer/index.html index 4f0ff48b..b19b7725 100644 --- a/dev/sidekick/Sidekick_smt_solver/Tracer/index.html +++ b/dev/sidekick/Sidekick_smt_solver/Tracer/index.html @@ -1,12 +1,12 @@ -Tracer (sidekick.Sidekick_smt_solver.Tracer)

Module Sidekick_smt_solver.Tracer

Tracer for SMT solvers.

The tracer is used to track clauses and terms used or deduced during proof search.

module Tr = Sidekick_trace
module Proof = Sidekick_proof
class type t = object ... end
class dummy : t

Dummy tracer

class concrete : Tr.Sink.t -> t

Tracer emitting to a sink

val dummy : t
val make : sink:Tr.Sink.t -> unit -> t
val assert_term : t -> Sidekick_core.Term.t -> Tr.Entry_id.t
val assert_term' : t -> Sidekick_core.Term.t -> unit
val assert_clause : +Tracer (sidekick.Sidekick_smt_solver.Tracer)

Module Sidekick_smt_solver.Tracer

Tracer for SMT solvers.

The tracer is used to track clauses and terms used or deduced during proof search.

module Tr = Sidekick_trace
module Proof = Sidekick_proof
class type t = object ... end
class dummy : t

Dummy tracer

class concrete : Tr.Sink.t -> t

Tracer emitting to a sink

val dummy : t
val make : sink:Tr.Sink.t -> unit -> t
val assert_term : t -> Sidekick_core.Term.t -> Tr.Entry_id.t
val assert_term' : t -> Sidekick_core.Term.t -> unit
val assert_clause : t -> - id:int -> + id:int -> Sidekick_core.Lit.t Iter.t -> Proof.Step.id -> Tr.Entry_id.t
val assert_clause' : t -> - id:int -> + id:int -> Sidekick_core.Lit.t Iter.t -> Proof.Step.id -> - unit
val delete_clause : t -> id:int -> Sidekick_core.Lit.t Iter.t -> unit
val unsat_clause : t -> id:int -> Tr.Entry_id.t
val unsat_clause' : t -> id:int -> unit
\ No newline at end of file + unit
val delete_clause : t -> id:int -> Sidekick_core.Lit.t Iter.t -> unit
val unsat_clause : t -> id:int -> Tr.Entry_id.t
val unsat_clause' : t -> id:int -> unit
diff --git a/dev/sidekick/Sidekick_smt_solver/index.html b/dev/sidekick/Sidekick_smt_solver/index.html index 1fe82065..60afcfe1 100644 --- a/dev/sidekick/Sidekick_smt_solver/index.html +++ b/dev/sidekick/Sidekick_smt_solver/index.html @@ -1,2 +1,2 @@ -Sidekick_smt_solver (sidekick.Sidekick_smt_solver)

Module Sidekick_smt_solver

Core of the SMT solver using Sidekick_sat

Sidekick_sat (in src/sat/) is a modular SAT solver in pure OCaml.

This builds a SMT solver on top of it.

module Sigs : sig ... end

Signature for the main SMT solver types.

module Model_builder : sig ... end

Model Builder.

module Registry : sig ... end

Registry to extract values

module Solver_internal : sig ... end

A view of the solver from a theory's point of view.

module Solver : sig ... end

Main solver type, user facing.

module Model : sig ... end

SMT models.

module Theory : sig ... end

Signatures for theory plugins

module Theory_id : sig ... end
module Preprocess : sig ... end

Preprocessor

module Find_foreign : sig ... end

Find foreign variables.

module Tracer : sig ... end

Tracer for SMT solvers.

module Trace_reader : sig ... end

Read trace

type theory = Theory.t
type solver = Solver.t
\ No newline at end of file +Sidekick_smt_solver (sidekick.Sidekick_smt_solver)

Module Sidekick_smt_solver

Core of the SMT solver using Sidekick_sat

Sidekick_sat (in src/sat/) is a modular SAT solver in pure OCaml.

This builds a SMT solver on top of it.

module Sigs : sig ... end

Signature for the main SMT solver types.

module Model_builder : sig ... end

Model Builder.

module Registry : sig ... end

Registry to extract values

module Solver_internal : sig ... end

A view of the solver from a theory's point of view.

module Solver : sig ... end

Main solver type, user facing.

module Model : sig ... end

SMT models.

module Theory : sig ... end

Signatures for theory plugins

module Theory_id : sig ... end
module Preprocess : sig ... end

Preprocessor

module Find_foreign : sig ... end

Find foreign variables.

module Tracer : sig ... end

Tracer for SMT solvers.

module Trace_reader : sig ... end

Read trace

type theory = Theory.t
type solver = Solver.t
diff --git a/dev/sidekick/Sidekick_tef/.dummy b/dev/sidekick/Sidekick_tef/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_tef/index.html b/dev/sidekick/Sidekick_tef/index.html deleted file mode 100644 index 1dc57bb2..00000000 --- a/dev/sidekick/Sidekick_tef/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Sidekick_tef (sidekick.Sidekick_tef)

Module Sidekick_tef

Tracing Event Format

A nice profiling format based on json, useful for visualizing what goes on. It provides a backend for Sidekick_util.Profile so that profiling probes will emit TEF events.

Profiling is enabled if setup is called, and if the environment variable "TRACE" is set to "1" or "true". The trace is emitted in the file "trace.json.gz" in the directory where the solver is launched; you can open it in chrome/chromium at "chrome://tracing".

Tracy can import (uncompressed) trace files with a nice native trace explorer.

See the documentation of TEF

val setup : unit -> unit

Install the TEF logger as a profiling backend.

val teardown : unit -> unit
val with_setup : (unit -> 'a) -> 'a
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_th_bool_dyn/.dummy b/dev/sidekick/Sidekick_th_bool_dyn/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_th_bool_dyn/Intf/index.html b/dev/sidekick/Sidekick_th_bool_dyn/Intf/index.html index fbf055e5..a52aa580 100644 --- a/dev/sidekick/Sidekick_th_bool_dyn/Intf/index.html +++ b/dev/sidekick/Sidekick_th_bool_dyn/Intf/index.html @@ -1,2 +1,2 @@ -Intf (sidekick.Sidekick_th_bool_dyn.Intf)

Module Sidekick_th_bool_dyn.Intf

module Proof = Sidekick_proof
module SMT = Sidekick_smt_solver
module Simplify = Sidekick_simplify
type 'a bool_view = 'a Sidekick_core.Bool_view.t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a

Boolean-oriented view of terms

module type ARG = sig ... end

Argument to the theory

\ No newline at end of file +Intf (sidekick.Sidekick_th_bool_dyn.Intf)

Module Sidekick_th_bool_dyn.Intf

module Proof = Sidekick_proof
module SMT = Sidekick_smt_solver
module Simplify = Sidekick_simplify
type 'a bool_view = 'a Sidekick_core.Bool_view.t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a

Boolean-oriented view of terms

module type ARG = sig ... end

Argument to the theory

diff --git a/dev/sidekick/Sidekick_th_bool_dyn/Intf/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_bool_dyn/Intf/module-type-ARG/index.html index eef6bbef..10ee399f 100644 --- a/dev/sidekick/Sidekick_th_bool_dyn/Intf/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_th_bool_dyn/Intf/module-type-ARG/index.html @@ -1,2 +1,2 @@ -ARG (sidekick.Sidekick_th_bool_dyn.Intf.ARG)

Module type Intf.ARG

Argument to the theory

val view_as_bool : term -> term bool_view

Project the term into the boolean view.

Make a term from the given boolean view.

\ No newline at end of file +ARG (sidekick.Sidekick_th_bool_dyn.Intf.ARG)

Module type Intf.ARG

Argument to the theory

val view_as_bool : term -> term bool_view

Project the term into the boolean view.

Make a term from the given boolean view.

diff --git a/dev/sidekick/Sidekick_th_bool_dyn/Proof_rules/index.html b/dev/sidekick/Sidekick_th_bool_dyn/Proof_rules/index.html index 590f52e9..0866d605 100644 --- a/dev/sidekick/Sidekick_th_bool_dyn/Proof_rules/index.html +++ b/dev/sidekick/Sidekick_th_bool_dyn/Proof_rules/index.html @@ -1,2 +1,2 @@ -Proof_rules (sidekick.Sidekick_th_bool_dyn.Proof_rules)

Module Sidekick_th_bool_dyn.Proof_rules

module Proof = Sidekick_proof
val lemma_bool_tauto : lit list -> Proof.Pterm.t

Boolean tautology lemma (clause)

val lemma_bool_c : string -> term list -> Proof.Pterm.t

Basic boolean logic lemma for a clause |- c. proof_bool_c b name cs is the Proof.Pterm.t designated by name.

val lemma_bool_equiv : term -> term -> Proof.Pterm.t

Boolean tautology lemma (equivalence)

val lemma_ite_true : ite:term -> Proof.Pterm.t

lemma a ==> ite a b c = b

val lemma_ite_false : ite:term -> Proof.Pterm.t

lemma ¬a ==> ite a b c = c

\ No newline at end of file +Proof_rules (sidekick.Sidekick_th_bool_dyn.Proof_rules)

Module Sidekick_th_bool_dyn.Proof_rules

module Proof = Sidekick_proof
val lemma_bool_tauto : lit list -> Proof.Pterm.t

Boolean tautology lemma (clause)

val lemma_bool_c : string -> term list -> Proof.Pterm.t

Basic boolean logic lemma for a clause |- c. proof_bool_c b name cs is the Proof.Pterm.t designated by name.

val lemma_bool_equiv : term -> term -> Proof.Pterm.t

Boolean tautology lemma (equivalence)

val lemma_ite_true : ite:term -> Proof.Pterm.t

lemma a ==> ite a b c = b

val lemma_ite_false : ite:term -> Proof.Pterm.t

lemma ¬a ==> ite a b c = c

diff --git a/dev/sidekick/Sidekick_th_bool_dyn/index.html b/dev/sidekick/Sidekick_th_bool_dyn/index.html index 70ff8ad6..f7c69870 100644 --- a/dev/sidekick/Sidekick_th_bool_dyn/index.html +++ b/dev/sidekick/Sidekick_th_bool_dyn/index.html @@ -1,2 +1,2 @@ -Sidekick_th_bool_dyn (sidekick.Sidekick_th_bool_dyn)

Module Sidekick_th_bool_dyn

Theory of boolean formulas.

This handles formulas containing "and", "or", "=>", "if-then-else", etc.

The difference with Sidekick_th_bool_static is that here, clausification of a formula F is done only when F is on the trail.

module Intf : sig ... end
module Proof_rules : sig ... end
module type ARG = Intf.ARG
val theory : (module ARG) -> Intf.SMT.Theory.t
\ No newline at end of file +Sidekick_th_bool_dyn (sidekick.Sidekick_th_bool_dyn)

Module Sidekick_th_bool_dyn

Theory of boolean formulas.

This handles formulas containing "and", "or", "=>", "if-then-else", etc.

The difference with Sidekick_th_bool_static is that here, clausification of a formula F is done only when F is on the trail.

module Intf : sig ... end
module Proof_rules : sig ... end
module type ARG = Intf.ARG
val theory : (module ARG) -> Intf.SMT.Theory.t
diff --git a/dev/sidekick/Sidekick_th_bool_static/.dummy b/dev/sidekick/Sidekick_th_bool_static/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_th_bool_static/Intf/index.html b/dev/sidekick/Sidekick_th_bool_static/Intf/index.html index 7ed359c6..a7a6ba26 100644 --- a/dev/sidekick/Sidekick_th_bool_static/Intf/index.html +++ b/dev/sidekick/Sidekick_th_bool_static/Intf/index.html @@ -1,2 +1,2 @@ -Intf (sidekick.Sidekick_th_bool_static.Intf)

Module Sidekick_th_bool_static.Intf

module Proof = Sidekick_proof
module SMT = Sidekick_smt_solver
module Simplify = Sidekick_simplify
type 'a bool_view = 'a Sidekick_core.Bool_view.t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a

Boolean-oriented view of terms

module type ARG = sig ... end

Argument to the theory

\ No newline at end of file +Intf (sidekick.Sidekick_th_bool_static.Intf)

Module Sidekick_th_bool_static.Intf

module Proof = Sidekick_proof
module SMT = Sidekick_smt_solver
module Simplify = Sidekick_simplify
type 'a bool_view = 'a Sidekick_core.Bool_view.t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a

Boolean-oriented view of terms

module type ARG = sig ... end

Argument to the theory

diff --git a/dev/sidekick/Sidekick_th_bool_static/Intf/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_bool_static/Intf/module-type-ARG/index.html index 993a5ad2..458f0fb7 100644 --- a/dev/sidekick/Sidekick_th_bool_static/Intf/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_th_bool_static/Intf/module-type-ARG/index.html @@ -1,2 +1,2 @@ -ARG (sidekick.Sidekick_th_bool_static.Intf.ARG)

Module type Intf.ARG

Argument to the theory

val view_as_bool : term -> term bool_view

Project the term into the boolean view.

Make a term from the given boolean view.

\ No newline at end of file +ARG (sidekick.Sidekick_th_bool_static.Intf.ARG)

Module type Intf.ARG

Argument to the theory

val view_as_bool : term -> term bool_view

Project the term into the boolean view.

Make a term from the given boolean view.

diff --git a/dev/sidekick/Sidekick_th_bool_static/Proof_rules/index.html b/dev/sidekick/Sidekick_th_bool_static/Proof_rules/index.html index 2a48b125..276e5c28 100644 --- a/dev/sidekick/Sidekick_th_bool_static/Proof_rules/index.html +++ b/dev/sidekick/Sidekick_th_bool_static/Proof_rules/index.html @@ -1,2 +1,2 @@ -Proof_rules (sidekick.Sidekick_th_bool_static.Proof_rules)

Module Sidekick_th_bool_static.Proof_rules

module Proof = Sidekick_proof
val lemma_bool_tauto : lit list -> Proof.Pterm.t

Boolean tautology lemma (clause)

val lemma_bool_c : string -> term list -> Proof.Pterm.t

Basic boolean logic lemma for a clause |- c. proof_bool_c b name cs is the Proof_term.t designated by name.

val lemma_bool_equiv : term -> term -> Proof.Pterm.t

Boolean tautology lemma (equivalence)

val lemma_ite_true : ite:term -> Proof.Pterm.t

lemma a ==> ite a b c = b

val lemma_ite_false : ite:term -> Proof.Pterm.t

lemma ¬a ==> ite a b c = c

\ No newline at end of file +Proof_rules (sidekick.Sidekick_th_bool_static.Proof_rules)

Module Sidekick_th_bool_static.Proof_rules

module Proof = Sidekick_proof
val lemma_bool_tauto : lit list -> Proof.Pterm.t

Boolean tautology lemma (clause)

val lemma_bool_c : string -> term list -> Proof.Pterm.t

Basic boolean logic lemma for a clause |- c. proof_bool_c b name cs is the Proof_term.t designated by name.

val lemma_bool_equiv : term -> term -> Proof.Pterm.t

Boolean tautology lemma (equivalence)

val lemma_ite_true : ite:term -> Proof.Pterm.t

lemma a ==> ite a b c = b

val lemma_ite_false : ite:term -> Proof.Pterm.t

lemma ¬a ==> ite a b c = c

diff --git a/dev/sidekick/Sidekick_th_bool_static/index.html b/dev/sidekick/Sidekick_th_bool_static/index.html index 65cc104f..227762c5 100644 --- a/dev/sidekick/Sidekick_th_bool_static/index.html +++ b/dev/sidekick/Sidekick_th_bool_static/index.html @@ -1,2 +1,2 @@ -Sidekick_th_bool_static (sidekick.Sidekick_th_bool_static)

Module Sidekick_th_bool_static

Theory of boolean formulas.

This handles formulas containing "and", "or", "=>", "if-then-else", etc.

module Intf : sig ... end
module Proof_rules : sig ... end
module type ARG = Intf.ARG
val theory : (module ARG) -> Intf.SMT.Theory.t
\ No newline at end of file +Sidekick_th_bool_static (sidekick.Sidekick_th_bool_static)

Module Sidekick_th_bool_static

Theory of boolean formulas.

This handles formulas containing "and", "or", "=>", "if-then-else", etc.

module Intf : sig ... end
module Proof_rules : sig ... end
module type ARG = Intf.ARG
val theory : (module ARG) -> Intf.SMT.Theory.t
diff --git a/dev/sidekick/Sidekick_th_cstor/.dummy b/dev/sidekick/Sidekick_th_cstor/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_th_cstor/index.html b/dev/sidekick/Sidekick_th_cstor/index.html index f942e9aa..a78af586 100644 --- a/dev/sidekick/Sidekick_th_cstor/index.html +++ b/dev/sidekick/Sidekick_th_cstor/index.html @@ -1,2 +1,2 @@ -Sidekick_th_cstor (sidekick.Sidekick_th_cstor)

Module Sidekick_th_cstor

Theory for constructors

module SMT = Sidekick_smt_solver
type ('c, 't) cstor_view =
  1. | T_cstor of 'c * 't array
  2. | T_other of 't
module type ARG = sig ... end
val make : (module ARG) -> SMT.theory
\ No newline at end of file +Sidekick_th_cstor (sidekick.Sidekick_th_cstor)

Module Sidekick_th_cstor

Theory for constructors

module SMT = Sidekick_smt_solver
type ('c, 't) cstor_view =
  1. | T_cstor of 'c * 't array
  2. | T_other of 't
module type ARG = sig ... end
val make : (module ARG) -> SMT.theory
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/index.html index f9979f51..8786160f 100644 --- a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/index.html @@ -1,4 +1,4 @@ -ARG (sidekick.Sidekick_th_cstor.ARG)

Module type Sidekick_th_cstor.ARG

val view_as_cstor : +ARG (sidekick.Sidekick_th_cstor.ARG)

Module type Sidekick_th_cstor.ARG

\ No newline at end of file + (Sidekick_core.Const.t, Sidekick_core.Term.t) cstor_view
diff --git a/dev/sidekick/Sidekick_th_data/.dummy b/dev/sidekick/Sidekick_th_data/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_th_data/index.html b/dev/sidekick/Sidekick_th_data/index.html index 72631d60..fc772944 100644 --- a/dev/sidekick/Sidekick_th_data/index.html +++ b/dev/sidekick/Sidekick_th_data/index.html @@ -1,2 +1,2 @@ -Sidekick_th_data (sidekick.Sidekick_th_data)

Module Sidekick_th_data

Theory for datatypes.

module SMT = Sidekick_smt_solver
type ('c, 't) data_view =
  1. | T_cstor of 'c * 't list
  2. | T_select of 'c * int * 't
  3. | T_is_a of 'c * 't
  4. | T_other of 't

Datatype-oriented view of terms.

  • 'c is the representation of constructors
  • 't is the representation of terms
type ('c, 'ty) data_ty_view =
  1. | Ty_arrow of 'ty list * 'ty
  2. | Ty_data of {
    1. cstors : 'c;
    }
  3. | Ty_other of {
    1. sub : 'ty list;
    }

View of types in a way that is directly useful for the theory of datatypes

module type DATA_TY = sig ... end

An abtract representation of a datatype

module type ARG = sig ... end
val make : (module ARG) -> SMT.theory
\ No newline at end of file +Sidekick_th_data (sidekick.Sidekick_th_data)

Module Sidekick_th_data

Theory for datatypes.

module SMT = Sidekick_smt_solver
type ('c, 't) data_view =
  1. | T_cstor of 'c * 't list
  2. | T_select of 'c * int * 't
  3. | T_is_a of 'c * 't
  4. | T_other of 't

Datatype-oriented view of terms.

  • 'c is the representation of constructors
  • 't is the representation of terms
type ('c, 'ty) data_ty_view =
  1. | Ty_arrow of 'ty list * 'ty
  2. | Ty_data of {
    1. cstors : 'c;
    }
  3. | Ty_other of {
    1. sub : 'ty list;
    }

View of types in a way that is directly useful for the theory of datatypes

module type DATA_TY = sig ... end

An abtract representation of a datatype

module type ARG = sig ... end
val make : (module ARG) -> SMT.theory
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/Cstor/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/Cstor/index.html index 11089789..a0508f53 100644 --- a/dev/sidekick/Sidekick_th_data/module-type-ARG/Cstor/index.html +++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/Cstor/index.html @@ -1,2 +1,2 @@ -Cstor (sidekick.Sidekick_th_data.ARG.Cstor)

Module ARG.Cstor

Constructor symbols.

A constructor is an injective symbol, part of a datatype (or "sum type"). For example, in type option a = Some a | None, the constructors are Some and None.

type t

Constructor

val ty_args : t -> ty list

Type arguments, for a polymorphic constructor

include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Cstor (sidekick.Sidekick_th_data.ARG.Cstor)

Module ARG.Cstor

Constructor symbols.

A constructor is an injective symbol, part of a datatype (or "sum type"). For example, in type option a = Some a | None, the constructors are Some and None.

type t

Constructor

val ty_args : t -> ty list

Type arguments, for a polymorphic constructor

include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html index 10f7bbc2..3690ca0b 100644 --- a/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html @@ -1,5 +1,5 @@ -ARG (sidekick.Sidekick_th_data.ARG)

Module type Sidekick_th_data.ARG

module Cstor : sig ... end

Constructor symbols.

val as_datatype : ty -> (Cstor.t list, ty) data_ty_view

Try to view type as a datatype (with its constructors)

val view_as_data : +ARG (sidekick.Sidekick_th_data.ARG)

Module type Sidekick_th_data.ARG

module Cstor : sig ... end

Constructor symbols.

val as_datatype : ty -> (Cstor.t list, ty) data_ty_view

Try to view type as a datatype (with its constructors)

Try to view Term.t as a datatype Term.t

Make a Term.t equality

val ty_is_finite : ty -> bool

Is the given type known to be finite? For example a finite datatype (an "enum" in C parlance), or Bool, or Array Bool Bool.

val ty_set_is_finite : ty -> bool -> unit

Modify the "finite" field (see ty_is_finite)

\ No newline at end of file + Sidekick_core.Term.t

Make a Term.t equality

val ty_is_finite : ty -> bool

Is the given type known to be finite? For example a finite datatype (an "enum" in C parlance), or Bool, or Array Bool Bool.

val ty_set_is_finite : ty -> bool -> unit

Modify the "finite" field (see ty_is_finite)

diff --git a/dev/sidekick/Sidekick_th_data/module-type-DATA_TY/index.html b/dev/sidekick/Sidekick_th_data/module-type-DATA_TY/index.html index 1f18b08a..7797fe0c 100644 --- a/dev/sidekick/Sidekick_th_data/module-type-DATA_TY/index.html +++ b/dev/sidekick/Sidekick_th_data/module-type-DATA_TY/index.html @@ -1,2 +1,2 @@ -DATA_TY (sidekick.Sidekick_th_data.DATA_TY)

Module type Sidekick_th_data.DATA_TY

An abtract representation of a datatype

type t
type cstor
val equal : t -> t -> bool
val finite : t -> bool
val set_finite : t -> bool -> unit
val view : t -> (cstor, t) data_ty_view
val cstor_args : cstor -> t list
\ No newline at end of file +DATA_TY (sidekick.Sidekick_th_data.DATA_TY)

Module type Sidekick_th_data.DATA_TY

An abtract representation of a datatype

type t
type cstor
val equal : t -> t -> bool
val finite : t -> bool
val set_finite : t -> bool -> unit
val view : t -> (cstor, t) data_ty_view
val cstor_args : cstor -> t list
diff --git a/dev/sidekick/Sidekick_th_lra/.dummy b/dev/sidekick/Sidekick_th_lra/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_th_lra/Intf/index.html b/dev/sidekick/Sidekick_th_lra/Intf/index.html index 9f75974a..29ae5416 100644 --- a/dev/sidekick/Sidekick_th_lra/Intf/index.html +++ b/dev/sidekick/Sidekick_th_lra/Intf/index.html @@ -1,2 +1,2 @@ -Intf (sidekick.Sidekick_th_lra.Intf)

Module Sidekick_th_lra.Intf

module SMT = Sidekick_smt_solver
module Proof = Sidekick_proof
module Predicate = Sidekick_simplex.Predicate
module Linear_expr = Sidekick_simplex.Linear_expr
module Linear_expr_intf = Sidekick_simplex.Linear_expr_intf
module type INT = Sidekick_arith.INT
module type RATIONAL = Sidekick_arith.RATIONAL
module S_op = Sidekick_simplex.Op
type pred = Linear_expr_intf.bool_op =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
type op = Linear_expr_intf.op =
  1. | Plus
  2. | Minus
type ('num, 'a) lra_view =
  1. | LRA_pred of pred * 'a * 'a
  2. | LRA_op of op * 'a * 'a
  3. | LRA_mult of 'num * 'a
  4. | LRA_const of 'num
  5. | LRA_other of 'a
val map_view : ('a -> 'b) -> ('c, 'd) lra_view -> ('e, 'f) lra_view
module type ARG = sig ... end
\ No newline at end of file +Intf (sidekick.Sidekick_th_lra.Intf)

Module Sidekick_th_lra.Intf

module SMT = Sidekick_smt_solver
module Proof = Sidekick_proof
module Predicate = Sidekick_simplex.Predicate
module Linear_expr = Sidekick_simplex.Linear_expr
module Linear_expr_intf = Sidekick_simplex.Linear_expr_intf
module type INT = Sidekick_arith.INT
module type RATIONAL = Sidekick_arith.RATIONAL
module S_op = Sidekick_simplex.Op
type pred = Linear_expr_intf.bool_op =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
type op = Linear_expr_intf.op =
  1. | Plus
  2. | Minus
type ('num, 'a) lra_view =
  1. | LRA_pred of pred * 'a * 'a
  2. | LRA_op of op * 'a * 'a
  3. | LRA_mult of 'num * 'a
  4. | LRA_const of 'num
  5. | LRA_other of 'a
val map_view : ('a -> 'b) -> ('c, 'd) lra_view -> ('e, 'f) lra_view
module type ARG = sig ... end
diff --git a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Q/index.html b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Q/index.html index 4131c75c..f71000bc 100644 --- a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Q/index.html +++ b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_th_lra.Intf.ARG.Q)

Module ARG.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_th_lra.Intf.ARG.Q)

Module ARG.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

diff --git a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Z/index.html b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Z/index.html index 0b4de3a4..e1d65af1 100644 --- a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Z/index.html +++ b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Z/index.html @@ -1,2 +1,2 @@ -Z (sidekick.Sidekick_th_lra.Intf.ARG.Z)

Module ARG.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file +Z (sidekick.Sidekick_th_lra.Intf.ARG.Z)

Module ARG.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
diff --git a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/index.html index cdde25af..9aed36a1 100644 --- a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/index.html @@ -1,5 +1,5 @@ -ARG (sidekick.Sidekick_th_lra.Intf.ARG)

Module type Intf.ARG

module Z : INT
module Q : RATIONAL with type bigint = Z.t

Project the Term.t into the theory view

val mk_lra : +ARG (sidekick.Sidekick_th_lra.Intf.ARG)

Module type Intf.ARG

module Z : INT
module Q : RATIONAL with type bigint = Z.t

Project the Term.t into the theory view

Make a Term.t from the given theory view

val ty_real : Sidekick_core.Term.store -> ty

Build the type Q

val has_ty_real : Sidekick_core.Term.t -> bool

Does this term have the type Real

\ No newline at end of file + Sidekick_core.Term.t

Make a Term.t from the given theory view

val ty_real : Sidekick_core.Term.store -> ty

Build the type Q

val has_ty_real : Sidekick_core.Term.t -> bool

Does this term have the type Real

diff --git a/dev/sidekick/Sidekick_th_lra/index.html b/dev/sidekick/Sidekick_th_lra/index.html index 873ab8e2..1fb2cb23 100644 --- a/dev/sidekick/Sidekick_th_lra/index.html +++ b/dev/sidekick/Sidekick_th_lra/index.html @@ -1,2 +1,2 @@ -Sidekick_th_lra (sidekick.Sidekick_th_lra)

Module Sidekick_th_lra

Linear Rational Arithmetic

module Intf : sig ... end
module Predicate = Intf.Predicate
module SMT = Sidekick_smt_solver
module type INT = Intf.INT
module type RATIONAL = Intf.RATIONAL
module S_op = Sidekick_simplex.Op
type pred = Intf.pred =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
type op = Intf.op =
  1. | Plus
  2. | Minus
type ('num, 'a) lra_view = ('num, 'a) Intf.lra_view =
  1. | LRA_pred of pred * 'a * 'a
  2. | LRA_op of op * 'a * 'a
  3. | LRA_mult of 'num * 'a
  4. | LRA_const of 'num
  5. | LRA_other of 'a
val map_view : ('a -> 'b) -> ('c, 'a) lra_view -> ('c, 'b) lra_view
module type ARG = Intf.ARG
val theory : (module ARG) -> SMT.Theory.t
\ No newline at end of file +Sidekick_th_lra (sidekick.Sidekick_th_lra)

Module Sidekick_th_lra

Linear Rational Arithmetic

module Intf : sig ... end
module Predicate = Intf.Predicate
module SMT = Sidekick_smt_solver
module type INT = Intf.INT
module type RATIONAL = Intf.RATIONAL
module S_op = Sidekick_simplex.Op
type pred = Intf.pred =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
type op = Intf.op =
  1. | Plus
  2. | Minus
type ('num, 'a) lra_view = ('num, 'a) Intf.lra_view =
  1. | LRA_pred of pred * 'a * 'a
  2. | LRA_op of op * 'a * 'a
  3. | LRA_mult of 'num * 'a
  4. | LRA_const of 'num
  5. | LRA_other of 'a
val map_view : ('a -> 'b) -> ('c, 'a) lra_view -> ('c, 'b) lra_view
module type ARG = Intf.ARG
val theory : (module ARG) -> SMT.Theory.t
diff --git a/dev/sidekick/Sidekick_th_ty_unin/.dummy b/dev/sidekick/Sidekick_th_ty_unin/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_th_ty_unin/index.html b/dev/sidekick/Sidekick_th_ty_unin/index.html index 84ba2594..633635e4 100644 --- a/dev/sidekick/Sidekick_th_ty_unin/index.html +++ b/dev/sidekick/Sidekick_th_ty_unin/index.html @@ -1,2 +1,2 @@ -Sidekick_th_ty_unin (sidekick.Sidekick_th_ty_unin)

Module Sidekick_th_ty_unin

module type ARG = sig ... end
val theory : (module ARG) -> Sidekick_smt_solver.Theory.t

Theory of uninterpreted types

\ No newline at end of file +Sidekick_th_ty_unin (sidekick.Sidekick_th_ty_unin)

Module Sidekick_th_ty_unin

module type ARG = sig ... end
val theory : (module ARG) -> Sidekick_smt_solver.Theory.t

Theory of uninterpreted types

diff --git a/dev/sidekick/Sidekick_th_ty_unin/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_ty_unin/module-type-ARG/index.html index 5c4474ce..e6d39eb5 100644 --- a/dev/sidekick/Sidekick_th_ty_unin/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_th_ty_unin/module-type-ARG/index.html @@ -1,2 +1,2 @@ -ARG (sidekick.Sidekick_th_ty_unin.ARG)

Module type Sidekick_th_ty_unin.ARG

val ty_is_unin : ty -> bool
\ No newline at end of file +ARG (sidekick.Sidekick_th_ty_unin.ARG)

Module type Sidekick_th_ty_unin.ARG

val ty_is_unin : ty -> bool
diff --git a/dev/sidekick/Sidekick_trace/.dummy b/dev/sidekick/Sidekick_trace/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_trace/Entry_id/index.html b/dev/sidekick/Sidekick_trace/Entry_id/index.html index d4ccd4b4..868165b4 100644 --- a/dev/sidekick/Sidekick_trace/Entry_id/index.html +++ b/dev/sidekick/Sidekick_trace/Entry_id/index.html @@ -1,2 +1,2 @@ -Entry_id (sidekick.Sidekick_trace.Entry_id)

Module Sidekick_trace.Entry_id

Entry in the sink.

This integer tag represent a single entry in a trace, for example a line if we serialized using line-separate json values. In general each entry has its own unique ID that is monotonically increasing with time.

include sig ... end
type t = int
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : int CCHash.t
val pp : int CCFormat.printer
val to_int : 'a -> 'a
val of_int_unsafe : int -> t
val dummy : t

Dummy id

\ No newline at end of file +Entry_id (sidekick.Sidekick_trace.Entry_id)

Module Sidekick_trace.Entry_id

Entry in the sink.

This integer tag represent a single entry in a trace, for example a line if we serialized using line-separate json values. In general each entry has its own unique ID that is monotonically increasing with time.

include sig ... end
type t = int
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : int CCHash.t
val pp : int CCFormat.printer
val to_int : 'a -> 'a
val of_int_unsafe : int -> t
val dummy : t

Dummy id

diff --git a/dev/sidekick/Sidekick_trace/Sink/index.html b/dev/sidekick/Sidekick_trace/Sink/index.html index 6c76f92c..b9218c40 100644 --- a/dev/sidekick/Sidekick_trace/Sink/index.html +++ b/dev/sidekick/Sidekick_trace/Sink/index.html @@ -1,2 +1,2 @@ -Sink (sidekick.Sidekick_trace.Sink)

Module Sidekick_trace.Sink

An IO sink for serialization/tracing

A trace is emitted on the fly into a sink. The sink collects or writes entries that are emitted into it.

type tag = string
module type S = sig ... end
type t = (module S)

Trace sink

val emit : t -> tag:tag -> Sidekick_util.Ser_value.t -> Entry_id.t
val emit' : t -> tag:tag -> Sidekick_util.Ser_value.t -> unit
val null : t

Sink that writes nowhere, just eats bytes.

val of_out_channel_using_bencode : Stdlib.out_channel -> t

A sink that emits entries using Bencode into the given channel

val of_buffer_using_bencode : Stdlib.Buffer.t -> t

Emit entries into the given buffer, in Bencode.

\ No newline at end of file +Sink (sidekick.Sidekick_trace.Sink)

Module Sidekick_trace.Sink

An IO sink for serialization/tracing

A trace is emitted on the fly into a sink. The sink collects or writes entries that are emitted into it.

type tag = string
module type S = sig ... end
type t = (module S)

Trace sink

val emit : t -> tag:tag -> Sidekick_util.Ser_value.t -> Entry_id.t
val emit' : t -> tag:tag -> Sidekick_util.Ser_value.t -> unit
val null : t

Sink that writes nowhere, just eats bytes.

val of_out_channel_using_bencode : Stdlib.out_channel -> t

A sink that emits entries using Bencode into the given channel

val of_buffer_using_bencode : Stdlib.Buffer.t -> t

Emit entries into the given buffer, in Bencode.

diff --git a/dev/sidekick/Sidekick_trace/Sink/module-type-S/index.html b/dev/sidekick/Sidekick_trace/Sink/module-type-S/index.html index 710081f6..4bbf3993 100644 --- a/dev/sidekick/Sidekick_trace/Sink/module-type-S/index.html +++ b/dev/sidekick/Sidekick_trace/Sink/module-type-S/index.html @@ -1,2 +1,2 @@ -S (sidekick.Sidekick_trace.Sink.S)

Module type Sink.S

\ No newline at end of file +S (sidekick.Sidekick_trace.Sink.S)

Module type Sink.S

diff --git a/dev/sidekick/Sidekick_trace/Source/index.html b/dev/sidekick/Sidekick_trace/Source/index.html index 06fea2fd..32420542 100644 --- a/dev/sidekick/Sidekick_trace/Source/index.html +++ b/dev/sidekick/Sidekick_trace/Source/index.html @@ -1,5 +1,5 @@ -Source (sidekick.Sidekick_trace.Source)

Module Sidekick_trace.Source

Source to read a trace.

A source is an IO input source that allows the read of individual entries of the trace, by providing their entry ID. It also allows to iterate on entries in chronological order.

type tag = string
module type S = sig ... end
type t = (module S)
val get_entry : t -> Entry_id.t -> (tag * Sidekick_util.Ser_value.t) option
val get_entry_exn : t -> Entry_id.t -> tag * Sidekick_util.Ser_value.t
val iter_all : +Source (sidekick.Sidekick_trace.Source)

Module Sidekick_trace.Source

Source to read a trace.

A source is an IO input source that allows the read of individual entries of the trace, by providing their entry ID. It also allows to iterate on entries in chronological order.

type tag = string
module type S = sig ... end
type t = (module S)
val get_entry : t -> Entry_id.t -> (tag * Sidekick_util.Ser_value.t) option
val get_entry_exn : t -> Entry_id.t -> tag * Sidekick_util.Ser_value.t
val iter_all : t -> - (Entry_id.t -> tag:tag -> Sidekick_util.Ser_value.t -> unit) -> - unit
val of_string_using_bencode : string -> t

Decode string, where entries are offsets

\ No newline at end of file + (Entry_id.t -> tag:tag -> Sidekick_util.Ser_value.t -> unit) -> + unit
val of_string_using_bencode : string -> t

Decode string, where entries are offsets

diff --git a/dev/sidekick/Sidekick_trace/Source/module-type-S/index.html b/dev/sidekick/Sidekick_trace/Source/module-type-S/index.html index 62741209..5907d787 100644 --- a/dev/sidekick/Sidekick_trace/Source/module-type-S/index.html +++ b/dev/sidekick/Sidekick_trace/Source/module-type-S/index.html @@ -1,4 +1,4 @@ -S (sidekick.Sidekick_trace.Source.S)

Module type Source.S

val get_entry : Entry_id.t -> tag * Sidekick_util.Ser_value.t
  • raises Not_found

    if there is no such entry

val iter_all : - (Entry_id.t -> tag:tag -> Sidekick_util.Ser_value.t -> unit) -> - unit

Iterate on all entries

\ No newline at end of file +S (sidekick.Sidekick_trace.Source.S)

Module type Source.S

val get_entry : Entry_id.t -> tag * Sidekick_util.Ser_value.t
  • raises Not_found

    if there is no such entry

val iter_all : + (Entry_id.t -> tag:tag -> Sidekick_util.Ser_value.t -> unit) -> + unit

Iterate on all entries

diff --git a/dev/sidekick/Sidekick_trace/index.html b/dev/sidekick/Sidekick_trace/index.html index 6cff16e4..bf4f14a2 100644 --- a/dev/sidekick/Sidekick_trace/index.html +++ b/dev/sidekick/Sidekick_trace/index.html @@ -1,2 +1,2 @@ -Sidekick_trace (sidekick.Sidekick_trace)

Module Sidekick_trace

Tracing.

Sidekick should be able to emit traces of some or all of the events happening inside its components (SAT solver, SMT solver, theories, etc.).

Traces can be written to disk and read back later from another process.

The two initial intended use cases are:

  • proof production (trace all inferences; reconstruct a proof from them starting from the inference of false)
  • debugging (trace some inferences/internal states/partial models; double check them later)

Exports

module Sink : sig ... end

An IO sink for serialization/tracing

module Source : sig ... end

Source to read a trace.

module Entry_id : sig ... end

Entry in the sink.

type entry_id = Entry_id.t
\ No newline at end of file +Sidekick_trace (sidekick.Sidekick_trace)

Module Sidekick_trace

Tracing.

Sidekick should be able to emit traces of some or all of the events happening inside its components (SAT solver, SMT solver, theories, etc.).

Traces can be written to disk and read back later from another process.

The two initial intended use cases are:

  • proof production (trace all inferences; reconstruct a proof from them starting from the inference of false)
  • debugging (trace some inferences/internal states/partial models; double check them later)

Exports

module Sink : sig ... end

An IO sink for serialization/tracing

module Source : sig ... end

Source to read a trace.

module Entry_id : sig ... end

Entry in the sink.

type entry_id = Entry_id.t
diff --git a/dev/sidekick/Sidekick_util/.dummy b/dev/sidekick/Sidekick_util/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_util/Backtrack_stack/index.html b/dev/sidekick/Sidekick_util/Backtrack_stack/index.html index c5d86801..728c080c 100644 --- a/dev/sidekick/Sidekick_util/Backtrack_stack/index.html +++ b/dev/sidekick/Sidekick_util/Backtrack_stack/index.html @@ -1,2 +1,2 @@ -Backtrack_stack (sidekick.Sidekick_util.Backtrack_stack)

Module Sidekick_util.Backtrack_stack

A backtracking stack

type 'a t
val create : unit -> 'a t
val push : 'a t -> 'a -> unit

Push an element onto the stack

val push_if_nonzero_level : 'a t -> 'a -> unit

Push an element onto the stack if level > 0

include Sidekick_sigs.BACKTRACKABLE1_CB with type 'a t := 'a t
include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : 'a t -> int -> f:('a -> unit) -> unit

pop_levels st n ~f removes n levels, calling f on every removed item

val iter : f:('a -> unit) -> 'a t -> unit
\ No newline at end of file +Backtrack_stack (sidekick.Sidekick_util.Backtrack_stack)

Module Sidekick_util.Backtrack_stack

A backtracking stack

type 'a t
val create : unit -> 'a t
val push : 'a t -> 'a -> unit

Push an element onto the stack

val push_if_nonzero_level : 'a t -> 'a -> unit

Push an element onto the stack if level > 0

include Sidekick_sigs.BACKTRACKABLE1_CB with type 'a t := 'a t
include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : 'a t -> int -> f:('a -> unit) -> unit

pop_levels st n ~f removes n levels, calling f on every removed item

val iter : f:('a -> unit) -> 'a t -> unit
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_ref/index.html b/dev/sidekick/Sidekick_util/Backtrackable_ref/index.html index a6960d90..86045706 100644 --- a/dev/sidekick/Sidekick_util/Backtrackable_ref/index.html +++ b/dev/sidekick/Sidekick_util/Backtrackable_ref/index.html @@ -1,2 +1,2 @@ -Backtrackable_ref (sidekick.Sidekick_util.Backtrackable_ref)

Module Sidekick_util.Backtrackable_ref

Backtrackable ref

type 'a t
val create : ?copy:('a -> 'a) -> 'a -> 'a t

Create a backtrackable reference holding the given value initially.

  • parameter copy

    if provided, will be used to copy the value when push_level is called.

val set : 'a t -> 'a -> unit

Set the reference's current content

val get : 'a t -> 'a

Get the reference's current content

val update : 'a t -> ('a -> 'a) -> unit

Update the reference's current content

include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : _ t -> int -> unit

pop_levels st n removes n levels

\ No newline at end of file +Backtrackable_ref (sidekick.Sidekick_util.Backtrackable_ref)

Module Sidekick_util.Backtrackable_ref

Backtrackable ref

type 'a t
val create : ?copy:('a -> 'a) -> 'a -> 'a t

Create a backtrackable reference holding the given value initially.

  • parameter copy

    if provided, will be used to copy the value when push_level is called.

val set : 'a t -> 'a -> unit

Set the reference's current content

val get : 'a t -> 'a

Get the reference's current content

val update : 'a t -> ('a -> 'a) -> unit

Update the reference's current content

include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : _ t -> int -> unit

pop_levels st n removes n levels

diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/argument-1-A/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/argument-1-A/index.html index fd72a2af..ddf5763b 100644 --- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/argument-1-A/index.html +++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/argument-1-A/index.html @@ -1,2 +1,2 @@ -A (sidekick.Sidekick_util.Backtrackable_tbl.Make.A)

Parameter Make.A

type t
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file +A (sidekick.Sidekick_util.Backtrackable_tbl.Make.A)

Parameter Make.A

type t
val equal : t -> t -> bool
val hash : t -> int
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/index.html index 70522f6f..178d9247 100644 --- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/index.html +++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/index.html @@ -1,2 +1,2 @@ -Make (sidekick.Sidekick_util.Backtrackable_tbl.Make)

Module Backtrackable_tbl.Make

Parameters

module A : ARG

Signature

type key = A.t
type 'a t
val create : ?size:int -> unit -> 'a t
val find : 'a t -> key -> 'a
  • raises Not_found

    if the key is not present

val get : 'a t -> key -> 'a option
val mem : _ t -> key -> bool
val length : _ t -> int
val iter : (key -> 'a -> unit) -> 'a t -> unit
val to_iter : 'a t -> (key * 'a) Iter.t
val add : 'a t -> key -> 'a -> unit
val remove : _ t -> key -> unit
include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : _ t -> int -> unit

pop_levels st n removes n levels

\ No newline at end of file +Make (sidekick.Sidekick_util.Backtrackable_tbl.Make)

Module Backtrackable_tbl.Make

Parameters

module A : ARG

Signature

type key = A.t
type 'a t
val create : ?size:int -> unit -> 'a t
val find : 'a t -> key -> 'a
  • raises Not_found

    if the key is not present

val get : 'a t -> key -> 'a option
val mem : _ t -> key -> bool
val length : _ t -> int
val iter : (key -> 'a -> unit) -> 'a t -> unit
val to_iter : 'a t -> (key * 'a) Iter.t
val add : 'a t -> key -> 'a -> unit
val remove : _ t -> key -> unit
include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : _ t -> int -> unit

pop_levels st n removes n levels

diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/index.html index afbf7ba5..9862c677 100644 --- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/index.html +++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/index.html @@ -1,2 +1,2 @@ -Backtrackable_tbl (sidekick.Sidekick_util.Backtrackable_tbl)

Module Sidekick_util.Backtrackable_tbl

A backtrackable hashtable

module type S = sig ... end
module type ARG = sig ... end
module Make (A : ARG) : S with type key = A.t
\ No newline at end of file +Backtrackable_tbl (sidekick.Sidekick_util.Backtrackable_tbl)

Module Sidekick_util.Backtrackable_tbl

A backtrackable hashtable

module type S = sig ... end
module type ARG = sig ... end
module Make (A : ARG) : S with type key = A.t
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-ARG/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-ARG/index.html index 78c650c1..96c1691a 100644 --- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-ARG/index.html +++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-ARG/index.html @@ -1,2 +1,2 @@ -ARG (sidekick.Sidekick_util.Backtrackable_tbl.ARG)

Module type Backtrackable_tbl.ARG

type t
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file +ARG (sidekick.Sidekick_util.Backtrackable_tbl.ARG)

Module type Backtrackable_tbl.ARG

type t
val equal : t -> t -> bool
val hash : t -> int
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-S/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-S/index.html index 8f750126..6cee9c0d 100644 --- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-S/index.html +++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-S/index.html @@ -1,2 +1,2 @@ -S (sidekick.Sidekick_util.Backtrackable_tbl.S)

Module type Backtrackable_tbl.S

type key
type 'a t
val create : ?size:int -> unit -> 'a t
val find : 'a t -> key -> 'a
  • raises Not_found

    if the key is not present

val get : 'a t -> key -> 'a option
val mem : _ t -> key -> bool
val length : _ t -> int
val iter : (key -> 'a -> unit) -> 'a t -> unit
val to_iter : 'a t -> (key * 'a) Iter.t
val add : 'a t -> key -> 'a -> unit
val remove : _ t -> key -> unit
include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : _ t -> int -> unit

pop_levels st n removes n levels

\ No newline at end of file +S (sidekick.Sidekick_util.Backtrackable_tbl.S)

Module type Backtrackable_tbl.S

type key
type 'a t
val create : ?size:int -> unit -> 'a t
val find : 'a t -> key -> 'a
  • raises Not_found

    if the key is not present

val get : 'a t -> key -> 'a option
val mem : _ t -> key -> bool
val length : _ t -> int
val iter : (key -> 'a -> unit) -> 'a t -> unit
val to_iter : 'a t -> (key * 'a) Iter.t
val add : 'a t -> key -> 'a -> unit
val remove : _ t -> key -> unit
include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
val n_levels : _ t -> int

Number of levels

val push_level : _ t -> unit

Push a backtracking point

val pop_levels : _ t -> int -> unit

pop_levels st n removes n levels

diff --git a/dev/sidekick/Sidekick_util/Bag/index.html b/dev/sidekick/Sidekick_util/Bag/index.html index a34f4608..5716c91e 100644 --- a/dev/sidekick/Sidekick_util/Bag/index.html +++ b/dev/sidekick/Sidekick_util/Bag/index.html @@ -1,2 +1,2 @@ -Bag (sidekick.Sidekick_util.Bag)

Module Sidekick_util.Bag

Ordered Bag of Elements

A data structure where we can have duplicate elements, optimized for fast concatenation and size.

type +'a t = private
  1. | E
  2. | L of 'a
  3. | N of 'a t * 'a t
val empty : 'a t
val is_empty : _ t -> bool
val return : 'a -> 'a t
val cons : 'a -> 'a t -> 'a t
val snoc : 'a t -> 'a -> 'a t
val append : 'a t -> 'a t -> 'a t
val of_iter : 'a Iter.t -> 'a t
val to_iter : 'a t -> 'a Iter.t
val to_list : 'a t -> 'a list
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
val iter : ('a -> unit) -> 'a t -> unit
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool

Are the two bags equal, element wise?

\ No newline at end of file +Bag (sidekick.Sidekick_util.Bag)

Module Sidekick_util.Bag

Ordered Bag of Elements

A data structure where we can have duplicate elements, optimized for fast concatenation and size.

type +'a t = private
  1. | E
  2. | L of 'a
  3. | N of 'a t * 'a t
val empty : 'a t
val is_empty : _ t -> bool
val return : 'a -> 'a t
val cons : 'a -> 'a t -> 'a t
val snoc : 'a t -> 'a -> 'a t
val append : 'a t -> 'a t -> 'a t
val of_iter : 'a Iter.t -> 'a t
val to_iter : 'a t -> 'a Iter.t
val to_list : 'a t -> 'a list
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
val iter : ('a -> unit) -> 'a t -> unit
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool

Are the two bags equal, element wise?

diff --git a/dev/sidekick/Sidekick_util/Bitvec/index.html b/dev/sidekick/Sidekick_util/Bitvec/index.html index 906d930b..242f6e65 100644 --- a/dev/sidekick/Sidekick_util/Bitvec/index.html +++ b/dev/sidekick/Sidekick_util/Bitvec/index.html @@ -1,2 +1,2 @@ -Bitvec (sidekick.Sidekick_util.Bitvec)

Module Sidekick_util.Bitvec

Bitvector.

This provides compact storage with O(1) access to a range of bits, like bool Vec.t but packed better.

type t
val create : unit -> t
val ensure_size : t -> int -> unit

ensure_size bv i ensures that i is a valid index in bv

val get : t -> int -> bool
val set : t -> int -> bool -> unit
val clear_all : t -> unit
\ No newline at end of file +Bitvec (sidekick.Sidekick_util.Bitvec)

Module Sidekick_util.Bitvec

Bitvector.

This provides compact storage with O(1) access to a range of bits, like bool Vec.t but packed better.

type t
val create : unit -> t
val ensure_size : t -> int -> unit

ensure_size bv i ensures that i is a valid index in bv

val get : t -> int -> bool
val set : t -> int -> bool -> unit
val clear_all : t -> unit
diff --git a/dev/sidekick/Sidekick_util/Chunk_stack/Buf/index.html b/dev/sidekick/Sidekick_util/Chunk_stack/Buf/index.html index 009d6f5e..85bc0485 100644 --- a/dev/sidekick/Sidekick_util/Chunk_stack/Buf/index.html +++ b/dev/sidekick/Sidekick_util/Chunk_stack/Buf/index.html @@ -1,2 +1,2 @@ -Buf (sidekick.Sidekick_util.Chunk_stack.Buf)

Module Chunk_stack.Buf

A hand made buffer

type t = {
  1. mutable b : bytes;
  2. mutable len : int;
}
val create : ?cap:int -> unit -> t
val clear : t -> unit
val contents : t -> string
\ No newline at end of file +Buf (sidekick.Sidekick_util.Chunk_stack.Buf)

Module Chunk_stack.Buf

A hand made buffer

type t = {
  1. mutable b : bytes;
  2. mutable len : int;
}
val create : ?cap:int -> unit -> t
val clear : t -> unit
val contents : t -> string
diff --git a/dev/sidekick/Sidekick_util/Chunk_stack/Reader/index.html b/dev/sidekick/Sidekick_util/Chunk_stack/Reader/index.html index dad8c6b8..42926790 100644 --- a/dev/sidekick/Sidekick_util/Chunk_stack/Reader/index.html +++ b/dev/sidekick/Sidekick_util/Chunk_stack/Reader/index.html @@ -1,2 +1,2 @@ -Reader (sidekick.Sidekick_util.Chunk_stack.Reader)

Module Chunk_stack.Reader

type t
val next : t -> yield:(bytes -> int -> int -> 'a) -> finish:(unit -> 'a) -> 'a

Read next chunk, call yield with a slice of bytes, otherwise call finish().

val next_string : t -> string option

Read next chunk as a string

val empty : t
val from_buf : Buf.t -> t
val from_channel_backward : ?close_at_end:bool -> Stdlib.in_channel -> t

Read channel from the end, assuming that is possible.

val with_file_backward : string -> (t -> 'a) -> 'a

read_file_backward filename f calls f with an iterator over chunks of the file, read from the end.

Each chunk is assumed to be followed by its length as an int32 LE.

\ No newline at end of file +Reader (sidekick.Sidekick_util.Chunk_stack.Reader)

Module Chunk_stack.Reader

type t
val next : t -> yield:(bytes -> int -> int -> 'a) -> finish:(unit -> 'a) -> 'a

Read next chunk, call yield with a slice of bytes, otherwise call finish().

val next_string : t -> string option

Read next chunk as a string

val empty : t
val from_buf : Buf.t -> t
val from_channel_backward : ?close_at_end:bool -> Stdlib.in_channel -> t

Read channel from the end, assuming that is possible.

val with_file_backward : string -> (t -> 'a) -> 'a

read_file_backward filename f calls f with an iterator over chunks of the file, read from the end.

Each chunk is assumed to be followed by its length as an int32 LE.

diff --git a/dev/sidekick/Sidekick_util/Chunk_stack/Writer/index.html b/dev/sidekick/Sidekick_util/Chunk_stack/Writer/index.html index b0e715eb..ba1b101b 100644 --- a/dev/sidekick/Sidekick_util/Chunk_stack/Writer/index.html +++ b/dev/sidekick/Sidekick_util/Chunk_stack/Writer/index.html @@ -1,2 +1,2 @@ -Writer (sidekick.Sidekick_util.Chunk_stack.Writer)

Module Chunk_stack.Writer

Create a stack of chunks.

type t
val dummy : t
val into_buf : Buf.t -> t
val into_channel : Stdlib.out_channel -> t
val add_buf : t -> Buf.t -> unit
val add_bytes : t -> bytes -> int -> int -> unit
val add_string : t -> string -> unit
val add_buffer : t -> Stdlib.Buffer.t -> unit
\ No newline at end of file +Writer (sidekick.Sidekick_util.Chunk_stack.Writer)

Module Chunk_stack.Writer

Create a stack of chunks.

type t
val dummy : t
val into_buf : Buf.t -> t
val into_channel : Stdlib.out_channel -> t
val add_buf : t -> Buf.t -> unit
val add_bytes : t -> bytes -> int -> int -> unit
val add_string : t -> string -> unit
val add_buffer : t -> Stdlib.Buffer.t -> unit
diff --git a/dev/sidekick/Sidekick_util/Chunk_stack/index.html b/dev/sidekick/Sidekick_util/Chunk_stack/index.html index f08fb4fa..13fed45c 100644 --- a/dev/sidekick/Sidekick_util/Chunk_stack/index.html +++ b/dev/sidekick/Sidekick_util/Chunk_stack/index.html @@ -1,2 +1,2 @@ -Chunk_stack (sidekick.Sidekick_util.Chunk_stack)

Module Sidekick_util.Chunk_stack

Manage a list of chunks.

A chunk is used for serializing proof traces, possibly on disk. This way we do not have to keep the whole proof in memory. Each chunk is typically one step of the proof search.

We produce chunks in forward order (chronological order of their discovery), but once we find a proof of "false", we work our way backward to find chunks transitively needed by this proof of false. Once we obtain this subset of the chunks (as a graph in memory) we can emit a proper proof with no redundant information.

module Buf : sig ... end

A hand made buffer

module Writer : sig ... end

Create a stack of chunks.

module Reader : sig ... end
\ No newline at end of file +Chunk_stack (sidekick.Sidekick_util.Chunk_stack)

Module Sidekick_util.Chunk_stack

Manage a list of chunks.

A chunk is used for serializing proof traces, possibly on disk. This way we do not have to keep the whole proof in memory. Each chunk is typically one step of the proof search.

We produce chunks in forward order (chronological order of their discovery), but once we find a proof of "false", we work our way backward to find chunks transitively needed by this proof of false. Once we obtain this subset of the chunks (as a graph in memory) we can emit a proper proof with no redundant information.

module Buf : sig ... end

A hand made buffer

module Writer : sig ... end

Create a stack of chunks.

module Reader : sig ... end
diff --git a/dev/sidekick/Sidekick_util/Error/index.html b/dev/sidekick/Sidekick_util/Error/index.html index 98491793..43b0b9da 100644 --- a/dev/sidekick/Sidekick_util/Error/index.html +++ b/dev/sidekick/Sidekick_util/Error/index.html @@ -1,2 +1,2 @@ -Error (sidekick.Sidekick_util.Error)

Module Sidekick_util.Error

exception Error of string
val errorf : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
  • raises Error

    when called

type nonrec 'a result = ('a, string) Stdlib.result
val try_ : (unit -> 'a) -> 'a result
\ No newline at end of file +Error (sidekick.Sidekick_util.Error)

Module Sidekick_util.Error

exception Error of string
val errorf : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
type nonrec 'a result = ('a, string) Stdlib.result
val try_ : (unit -> 'a) -> 'a result
diff --git a/dev/sidekick/Sidekick_util/Event/Emitter/index.html b/dev/sidekick/Sidekick_util/Event/Emitter/index.html index bfbbac1d..89bcc599 100644 --- a/dev/sidekick/Sidekick_util/Event/Emitter/index.html +++ b/dev/sidekick/Sidekick_util/Event/Emitter/index.html @@ -1,2 +1,2 @@ -Emitter (sidekick.Sidekick_util.Event.Emitter)

Module Event.Emitter

type ('a, 'b) t
val create : unit -> ('a, 'b) t
val emit : ('a, unit) t -> 'a -> unit
val emit_collect : ('a, 'b) t -> 'a -> 'b list
val emit_iter : ('a, 'b) t -> 'a -> f:('b -> unit) -> unit
\ No newline at end of file +Emitter (sidekick.Sidekick_util.Event.Emitter)

Module Event.Emitter

type ('a, 'b) t
val create : unit -> ('a, 'b) t
val emit : ('a, unit) t -> 'a -> unit
val emit_collect : ('a, 'b) t -> 'a -> 'b list
val emit_iter : ('a, 'b) t -> 'a -> f:('b -> unit) -> unit
diff --git a/dev/sidekick/Sidekick_util/Event/index.html b/dev/sidekick/Sidekick_util/Event/index.html index 53a7fa6f..46dd6781 100644 --- a/dev/sidekick/Sidekick_util/Event/index.html +++ b/dev/sidekick/Sidekick_util/Event/index.html @@ -1,2 +1,2 @@ -Event (sidekick.Sidekick_util.Event)

Module Sidekick_util.Event

Event pattern.

This provides a basic observer pattern, where events are emitted from some source (with an attached value), and callbacks that were registered will receive this value.

type ('a, 'b) t

An event emitting values of type 'a, where subscribers return values of type 'b.

module Emitter : sig ... end
val on : ('a, 'b) t -> f:('a -> 'b) -> unit
val of_emitter : ('a, 'b) Emitter.t -> ('a, 'b) t
val emit : ('a, unit) Emitter.t -> 'a -> unit
val emit_collect : ('a, 'b) Emitter.t -> 'a -> 'b list
val emit_iter : ('a, 'b) Emitter.t -> 'a -> f:('b -> unit) -> unit
\ No newline at end of file +Event (sidekick.Sidekick_util.Event)

Module Sidekick_util.Event

Event pattern.

This provides a basic observer pattern, where events are emitted from some source (with an attached value), and callbacks that were registered will receive this value.

type ('a, 'b) t

An event emitting values of type 'a, where subscribers return values of type 'b.

module Emitter : sig ... end
val on : ('a, 'b) t -> f:('a -> 'b) -> unit
val of_emitter : ('a, 'b) Emitter.t -> ('a, 'b) t
val emit : ('a, unit) Emitter.t -> 'a -> unit
val emit_collect : ('a, 'b) Emitter.t -> 'a -> 'b list
val emit_iter : ('a, 'b) Emitter.t -> 'a -> f:('b -> unit) -> unit
diff --git a/dev/sidekick/Sidekick_util/Hash/index.html b/dev/sidekick/Sidekick_util/Hash/index.html index e8fcc0a6..1ca0d409 100644 --- a/dev/sidekick/Sidekick_util/Hash/index.html +++ b/dev/sidekick/Sidekick_util/Hash/index.html @@ -1,2 +1,2 @@ -Hash (sidekick.Sidekick_util.Hash)

Module Sidekick_util.Hash

type 'a t = 'a -> int
val bool : bool t
val int : int t
val string : string t
val combine : 'a t -> int -> 'a -> int
val pair : 'a t -> 'b t -> ('a * 'b) t
val opt : 'a t -> 'a option t
val list : 'a t -> 'a list t
val array : 'a t -> 'a array t
val iarray : 'a t -> 'a array t
val seq : 'a t -> 'a Iter.t t
val combine2 : int -> int -> int
val combine3 : int -> int -> int -> int
val combine4 : int -> int -> int -> int -> int
val poly : 'a t

the regular polymorphic hash function

\ No newline at end of file +Hash (sidekick.Sidekick_util.Hash)

Module Sidekick_util.Hash

type 'a t = 'a -> int
val bool : bool t
val int : int t
val string : string t
val combine : 'a t -> int -> 'a -> int
val pair : 'a t -> 'b t -> ('a * 'b) t
val opt : 'a t -> 'a option t
val list : 'a t -> 'a list t
val array : 'a t -> 'a array t
val iarray : 'a t -> 'a array t
val seq : 'a t -> 'a Iter.t t
val combine2 : int -> int -> int
val combine3 : int -> int -> int -> int
val combine4 : int -> int -> int -> int -> int
val poly : 'a t

the regular polymorphic hash function

diff --git a/dev/sidekick/Sidekick_util/Int_id/Make/index.html b/dev/sidekick/Sidekick_util/Int_id/Make/index.html index ba241d14..79c6730f 100644 --- a/dev/sidekick/Sidekick_util/Int_id/Make/index.html +++ b/dev/sidekick/Sidekick_util/Int_id/Make/index.html @@ -1,2 +1,2 @@ -Make (sidekick.Sidekick_util.Int_id.Make)

Module Int_id.Make

Generate a new type for integer identifiers

Parameters

Signature

type t = int
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : int CCHash.t
val pp : int CCFormat.printer
val to_int : 'a -> 'b
val of_int_unsafe : int -> t
\ No newline at end of file +Make (sidekick.Sidekick_util.Int_id.Make)

Module Int_id.Make

Generate a new type for integer identifiers

Parameters

Signature

type t = int
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : int CCHash.t
val pp : int CCFormat.printer
val to_int : 'a -> 'b
val of_int_unsafe : int -> t
diff --git a/dev/sidekick/Sidekick_util/Int_id/index.html b/dev/sidekick/Sidekick_util/Int_id/index.html index caad44d0..f4bcca3d 100644 --- a/dev/sidekick/Sidekick_util/Int_id/index.html +++ b/dev/sidekick/Sidekick_util/Int_id/index.html @@ -1,2 +1,2 @@ -Int_id (sidekick.Sidekick_util.Int_id)

Module Sidekick_util.Int_id

Integer-based identifiers.

module type S = sig ... end
module Make () : sig ... end

Generate a new type for integer identifiers

\ No newline at end of file +Int_id (sidekick.Sidekick_util.Int_id)

Module Sidekick_util.Int_id

Integer-based identifiers.

module type S = sig ... end
module Make () : sig ... end

Generate a new type for integer identifiers

diff --git a/dev/sidekick/Sidekick_util/Int_id/module-type-S/index.html b/dev/sidekick/Sidekick_util/Int_id/module-type-S/index.html index 6c297b72..6f02d439 100644 --- a/dev/sidekick/Sidekick_util/Int_id/module-type-S/index.html +++ b/dev/sidekick/Sidekick_util/Int_id/module-type-S/index.html @@ -1,2 +1,2 @@ -S (sidekick.Sidekick_util.Int_id.S)

Module type Int_id.S

type t = private int
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val to_int : t -> int
val of_int_unsafe : int -> t
\ No newline at end of file +S (sidekick.Sidekick_util.Int_id.S)

Module type Int_id.S

type t = private int
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val to_int : t -> int
val of_int_unsafe : int -> t
diff --git a/dev/sidekick/Sidekick_util/Log/index.html b/dev/sidekick/Sidekick_util/Log/index.html index 6af8d55c..5c495cc8 100644 --- a/dev/sidekick/Sidekick_util/Log/index.html +++ b/dev/sidekick/Sidekick_util/Log/index.html @@ -1,5 +1,5 @@ -Log (sidekick.Sidekick_util.Log)

Module Sidekick_util.Log

Logging function, for debugging

val enabled : bool
val set_debug : int -> unit

Set debug level

val get_debug : unit -> int

Current debug level

val debugf : +Log (sidekick.Sidekick_util.Log)

Module Sidekick_util.Log

Logging function, for debugging

val enabled : bool
val set_debug : int -> unit

Set debug level

val get_debug : unit -> int

Current debug level

val debugf : int -> ((('a, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> 'a) -> unit) -> - unit

Emit a debug message at the given level. If the level is lower than get_debug (), the message will indeed be emitted

val debug : int -> string -> unit

Simpler version of debug, without formatting

val set_debug_out : Stdlib.Format.formatter -> unit

Change the output formatter.

\ No newline at end of file + unit

Emit a debug message at the given level. If the level is lower than get_debug (), the message will indeed be emitted

val debug : int -> string -> unit

Simpler version of debug, without formatting

val set_debug_out : Stdlib.Format.formatter -> unit

Change the output formatter.

diff --git a/dev/sidekick/Sidekick_util/Profile/Control/index.html b/dev/sidekick/Sidekick_util/Profile/Control/index.html deleted file mode 100644 index 3382b8f9..00000000 --- a/dev/sidekick/Sidekick_util/Profile/Control/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Control (sidekick.Sidekick_util.Profile.Control)

Module Profile.Control

val setup : backend option -> unit
val teardown : unit -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_util/Profile/index.html b/dev/sidekick/Sidekick_util/Profile/index.html index 66f13460..de5bc975 100644 --- a/dev/sidekick/Sidekick_util/Profile/index.html +++ b/dev/sidekick/Sidekick_util/Profile/index.html @@ -1,8 +1,43 @@ -Profile (sidekick.Sidekick_util.Profile)

Module Sidekick_util.Profile

Profiling probes.

This basic library can produce Catapult traces (a json file) that can be read at http://ui.perfetto.dev.

type probe
val null_probe : probe
val enabled : unit -> bool
val instant : ?args:(string * string) list -> string -> unit
val begin_ : string -> probe
val exit : ?args:(string * string) list -> probe -> unit
val with_ : ?args:(string * string) list -> string -> (unit -> 'a) -> 'a
val with1 : ?args:(string * string) list -> string -> ('a -> 'b) -> 'a -> 'b
val with2 : - ?args:(string * string) list -> +Profile (sidekick.Sidekick_util.Profile)

Module Sidekick_util.Profile

include module type of struct include Trace_core end
type span = int64
type user_data = [
  1. | `Bool of bool
  2. | `Float of float
  3. | `Int of int
  4. | `None
  5. | `String of string
]
type explicit_span = Trace_core__Types.explicit_span = {
  1. span : span;
  2. mutable meta : Trace_core__.Meta_map.t;
}
module Collector : sig ... end
module Meta_map : sig ... end
val enabled : unit -> bool
val with_span : + ?__FUNCTION__:string -> + __FILE__:string -> + __LINE__:int -> + ?data:(unit -> (string * user_data) list) -> string -> - ('a -> 'b -> 'c) -> - 'a -> - 'b -> - 'c
val count : string -> (string * int) list -> unit
module type BACKEND = sig ... end
type backend = (module BACKEND)
module Control : sig ... end
\ No newline at end of file + (span -> 'a) -> + 'a
val add_data_to_span : span -> (string * user_data) list -> unit
val enter_manual_sub_span : + parent:explicit_span -> + ?flavor:[ `Async | `Sync ] -> + ?__FUNCTION__:string -> + __FILE__:string -> + __LINE__:int -> + ?data:(unit -> (string * user_data) list) -> + string -> + explicit_span
val enter_manual_toplevel_span : + ?flavor:[ `Async | `Sync ] -> + ?__FUNCTION__:string -> + __FILE__:string -> + __LINE__:int -> + ?data:(unit -> (string * user_data) list) -> + string -> + explicit_span
val exit_manual_span : explicit_span -> unit
val add_data_to_manual_span : + explicit_span -> + (string * user_data) list -> + unit
val message : + ?span:span -> + ?data:(unit -> (string * user_data) list) -> + string -> + unit
val messagef : + ?span:span -> + ?data:(unit -> (string * user_data) list) -> + ((('a, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> 'a) -> unit) -> + unit
val set_thread_name : string -> unit
val set_process_name : string -> unit
val counter_int : + ?data:(unit -> (string * user_data) list) -> + string -> + int -> + unit
val counter_float : + ?data:(unit -> (string * user_data) list) -> + string -> + float -> + unit
type collector = (module Collector.S)
val setup_collector : collector -> unit
val shutdown : unit -> unit
module Internal_ = Trace_core.Internal_
diff --git a/dev/sidekick/Sidekick_util/Profile/module-type-BACKEND/index.html b/dev/sidekick/Sidekick_util/Profile/module-type-BACKEND/index.html deleted file mode 100644 index a312fb66..00000000 --- a/dev/sidekick/Sidekick_util/Profile/module-type-BACKEND/index.html +++ /dev/null @@ -1,13 +0,0 @@ - -BACKEND (sidekick.Sidekick_util.Profile.BACKEND)

Module type Profile.BACKEND

val get_ts : unit -> float
val emit_duration_event : - name:string -> - start:float -> - end_:float -> - args:(string * string) list -> - unit -> - unit
val emit_instant_event : - name:string -> - ts:float -> - args:(string * string) list -> - unit -> - unit
val emit_count_event : name:string -> ts:float -> (string * int) list -> unit
val teardown : unit -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_util/Ser_decode/Error/index.html b/dev/sidekick/Sidekick_util/Ser_decode/Error/index.html index 119f6f72..e3747987 100644 --- a/dev/sidekick/Sidekick_util/Ser_decode/Error/index.html +++ b/dev/sidekick/Sidekick_util/Ser_decode/Error/index.html @@ -1,2 +1,2 @@ -Error (sidekick.Sidekick_util.Ser_decode.Error)

Module Ser_decode.Error

Errors

type t
include Sidekick_sigs.PRINT with type t := t
val to_string : t -> string
val of_string : string -> Ser_value.t -> t
\ No newline at end of file +Error (sidekick.Sidekick_util.Ser_decode.Error)

Module Ser_decode.Error

Errors

type t
include Sidekick_sigs.PRINT with type t := t
val to_string : t -> string
val of_string : string -> Ser_value.t -> t
diff --git a/dev/sidekick/Sidekick_util/Ser_decode/Infix/index.html b/dev/sidekick/Sidekick_util/Ser_decode/Infix/index.html index 8180de92..9a60828a 100644 --- a/dev/sidekick/Sidekick_util/Ser_decode/Infix/index.html +++ b/dev/sidekick/Sidekick_util/Ser_decode/Infix/index.html @@ -1,2 +1,2 @@ -Infix (sidekick.Sidekick_util.Ser_decode.Infix)

Module Ser_decode.Infix

val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val let+ : 'a t -> ('a -> 'b) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ('a -> 'b t) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
\ No newline at end of file +Infix (sidekick.Sidekick_util.Ser_decode.Infix)

Module Ser_decode.Infix

val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val let+ : 'a t -> ('a -> 'b) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ('a -> 'b t) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
diff --git a/dev/sidekick/Sidekick_util/Ser_decode/index.html b/dev/sidekick/Sidekick_util/Ser_decode/index.html index ea30a19d..f9f94449 100644 --- a/dev/sidekick/Sidekick_util/Ser_decode/index.html +++ b/dev/sidekick/Sidekick_util/Ser_decode/index.html @@ -1,2 +1,2 @@ -Ser_decode (sidekick.Sidekick_util.Ser_decode)

Module Sidekick_util.Ser_decode

Decoders for Ser_value.

Combinators to decode values.

module Error : sig ... end

Errors

Main combinators

type +'a t

Decode a value of type 'a

val int : int t
val bool : bool t
val string : string t
val return : 'a -> 'a t
val return_result : ('a, string) Stdlib.result -> 'a t
val return_result_err : ('a, Error.t) Stdlib.result -> 'a t
val delay : (unit -> 'a t) -> 'a t
val fail : string -> 'a t
val failf : ('a, Stdlib.Format.formatter, unit, 'b t) Stdlib.format4 -> 'a
val fail_err : Error.t -> 'a t
val unwrap_opt : string -> 'a option -> 'a t

Unwrap option, or fail

val any : Ser_value.t t
val list : 'a t -> 'a list t
val tup2 : 'a t -> 'b t -> ('a * 'b) t
val tup3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val tup4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val dict_field : string -> 'a t -> 'a t
val dict_field_opt : string -> 'a t -> 'a option t
val dict_field_or : 'a -> string -> 'a t -> 'a t
val both : 'a t -> 'b t -> ('a * 'b) t
val reflect : 'a t -> Ser_value.t -> ('a, Error.t) Stdlib.result t

reflect dec v returns the result of decoding v with dec

val reflect_or_fail : 'a t -> Ser_value.t -> 'a t
val try_l : 'a t list -> 'a t

try_l fs tries each f in fs turn by turn, until one succeeds

module Infix : sig ... end
include module type of Infix
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val let+ : 'a t -> ('a -> 'b) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ('a -> 'b t) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t

Deserializing

val run : 'a t -> Ser_value.t -> ('a, Error.t) Stdlib.result
val run_exn : 'a t -> Ser_value.t -> 'a
  • raises Error.Error

    in case of failure

\ No newline at end of file +Ser_decode (sidekick.Sidekick_util.Ser_decode)

Module Sidekick_util.Ser_decode

Decoders for Ser_value.

Combinators to decode values.

module Error : sig ... end

Errors

Main combinators

type +'a t

Decode a value of type 'a

val int : int t
val bool : bool t
val string : string t
val return : 'a -> 'a t
val return_result : ('a, string) Stdlib.result -> 'a t
val return_result_err : ('a, Error.t) Stdlib.result -> 'a t
val delay : (unit -> 'a t) -> 'a t
val fail : string -> 'a t
val failf : ('a, Stdlib.Format.formatter, unit, 'b t) Stdlib.format4 -> 'a
val fail_err : Error.t -> 'a t
val unwrap_opt : string -> 'a option -> 'a t

Unwrap option, or fail

val any : Ser_value.t t
val list : 'a t -> 'a list t
val tup2 : 'a t -> 'b t -> ('a * 'b) t
val tup3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val tup4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val dict_field : string -> 'a t -> 'a t
val dict_field_opt : string -> 'a t -> 'a option t
val dict_field_or : 'a -> string -> 'a t -> 'a t
val both : 'a t -> 'b t -> ('a * 'b) t
val reflect : 'a t -> Ser_value.t -> ('a, Error.t) Stdlib.result t

reflect dec v returns the result of decoding v with dec

val reflect_or_fail : 'a t -> Ser_value.t -> 'a t
val try_l : 'a t list -> 'a t

try_l fs tries each f in fs turn by turn, until one succeeds

module Infix : sig ... end
include module type of Infix
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val let+ : 'a t -> ('a -> 'b) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ('a -> 'b t) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t

Deserializing

val run : 'a t -> Ser_value.t -> ('a, Error.t) Stdlib.result
val run_exn : 'a t -> Ser_value.t -> 'a
  • raises Error.Error

    in case of failure

diff --git a/dev/sidekick/Sidekick_util/Ser_value/index.html b/dev/sidekick/Sidekick_util/Ser_value/index.html index c58122f2..db074203 100644 --- a/dev/sidekick/Sidekick_util/Ser_value/index.html +++ b/dev/sidekick/Sidekick_util/Ser_value/index.html @@ -1,2 +1,2 @@ -Ser_value (sidekick.Sidekick_util.Ser_value)

Module Sidekick_util.Ser_value

Serialization representation.

A Ser_value.t describes how to serialized some structured data into bytes. It reflects the shape of the structured data but does not commit to a particular serialization format.

type t = private
  1. | Null
  2. | Bool of bool
  3. | Str of string
  4. | Bytes of string
  5. | Int of int
  6. | List of t list
val null : t
val bool : bool -> t
val int : int -> t
val string : string -> t
val bytes : string -> t
val list : t list -> t
val dict : t Sidekick_util__.Util.Str_map.t -> t
val dict_of_list : (string * t) list -> t
val is_null : t -> bool
include Sidekick_sigs.PRINT with type t := t
\ No newline at end of file +Ser_value (sidekick.Sidekick_util.Ser_value)

Module Sidekick_util.Ser_value

Serialization representation.

A Ser_value.t describes how to serialized some structured data into bytes. It reflects the shape of the structured data but does not commit to a particular serialization format.

type t = private
  1. | Null
  2. | Bool of bool
  3. | Str of string
  4. | Bytes of string
  5. | Int of int
  6. | List of t list
val null : t
val bool : bool -> t
val int : int -> t
val string : string -> t
val bytes : string -> t
val list : t list -> t
val dict : t Sidekick_util__.Util.Str_map.t -> t
val dict_of_list : (string * t) list -> t
val is_null : t -> bool
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick/Sidekick_util/Stat/index.html b/dev/sidekick/Sidekick_util/Stat/index.html index a67813d8..267621bc 100644 --- a/dev/sidekick/Sidekick_util/Stat/index.html +++ b/dev/sidekick/Sidekick_util/Stat/index.html @@ -1,2 +1,2 @@ -Stat (sidekick.Sidekick_util.Stat)

Module Sidekick_util.Stat

Statistics

module Fmt = CCFormat
type t
val create : unit -> t
type 'a counter
val mk_int : t -> string -> int counter
val mk_float : t -> string -> float counter
val incr : int counter -> unit
val incr_f : float counter -> float -> unit
val set : 'a counter -> 'a -> unit
type ex_counter

Existential counter

val all : t -> ex_counter Iter.t
val pp_counters : ex_counter Iter.t Fmt.printer
val pp : t Fmt.printer
val global : t

Global statistics, by default

\ No newline at end of file +Stat (sidekick.Sidekick_util.Stat)

Module Sidekick_util.Stat

Statistics

module Fmt = CCFormat
type t
val create : unit -> t
type 'a counter
val mk_int : t -> string -> int counter
val mk_float : t -> string -> float counter
val incr : int counter -> unit
val incr_f : float counter -> float -> unit
val set : 'a counter -> 'a -> unit
type ex_counter

Existential counter

val all : t -> ex_counter Iter.t
val pp_counters : ex_counter Iter.t Fmt.printer
val pp : t Fmt.printer
val global : t

Global statistics, by default

diff --git a/dev/sidekick/Sidekick_util/Util/index.html b/dev/sidekick/Sidekick_util/Util/index.html index 7bea4e4c..9658d102 100644 --- a/dev/sidekick/Sidekick_util/Util/index.html +++ b/dev/sidekick/Sidekick_util/Util/index.html @@ -1,2 +1,2 @@ -Util (sidekick.Sidekick_util.Util)

Module Sidekick_util.Util

Utils

type 'a printer = 'a CCFormat.printer
val pp_list : ?sep:string -> 'a printer -> 'a list printer
val pp_iter : ?sep:string -> 'a printer -> 'a Iter.t printer
val pp_array : ?sep:string -> 'a printer -> 'a array printer
val pp_pair : ?sep:string -> 'a printer -> 'b printer -> ('a * 'b) printer
val flat_map_l_arr : ('a -> 'b array) -> 'a list -> 'b list
val array_of_list_map : ('a -> 'b) -> 'a list -> 'b array

array_of_list_map f l is the same as Array.of_list @@ List.map f l

val array_to_list_map : ('a -> 'b) -> 'a array -> 'b list
val lazy_map : ('a -> 'b) -> 'a lazy_t -> 'b lazy_t
val lazy_map2 : ('a -> 'b -> 'c) -> 'a lazy_t -> 'b lazy_t -> 'c lazy_t
val array_iteri2 : f:(int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit
val setup_gc : unit -> unit

Change parameters of the GC

module Int_set : CCSet.S with type elt = int
module Int_map : CCMap.S with type key = int
module Int_tbl : CCHashtbl.S with type key = int
module Str_tbl : CCHashtbl.S with type key = string
module Str_map : CCMap.S with type key = string
\ No newline at end of file +Util (sidekick.Sidekick_util.Util)

Module Sidekick_util.Util

Utils

type 'a printer = 'a CCFormat.printer
val pp_list : ?sep:string -> 'a printer -> 'a list printer
val pp_iter : ?sep:string -> 'a printer -> 'a Iter.t printer
val pp_array : ?sep:string -> 'a printer -> 'a array printer
val pp_pair : ?sep:string -> 'a printer -> 'b printer -> ('a * 'b) printer
val flat_map_l_arr : ('a -> 'b array) -> 'a list -> 'b list
val array_of_list_map : ('a -> 'b) -> 'a list -> 'b array

array_of_list_map f l is the same as Array.of_list @@ List.map f l

val array_to_list_map : ('a -> 'b) -> 'a array -> 'b list
val lazy_map : ('a -> 'b) -> 'a lazy_t -> 'b lazy_t
val lazy_map2 : ('a -> 'b -> 'c) -> 'a lazy_t -> 'b lazy_t -> 'c lazy_t
val array_iteri2 : f:(int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit
val setup_gc : unit -> unit

Change parameters of the GC

module Int_set : CCSet.S with type elt = int
module Int_map : CCMap.S with type key = int
module Int_tbl : CCHashtbl.S with type key = int
module Str_tbl : CCHashtbl.S with type key = string
module Str_map : CCMap.S with type key = string
diff --git a/dev/sidekick/Sidekick_util/Vec/index.html b/dev/sidekick/Sidekick_util/Vec/index.html index a3319da3..ec4c3971 100644 --- a/dev/sidekick/Sidekick_util/Vec/index.html +++ b/dev/sidekick/Sidekick_util/Vec/index.html @@ -1,7 +1,7 @@ -Vec (sidekick.Sidekick_util.Vec)

Module Sidekick_util.Vec

Vectors

A resizable array, workhorse of imperative programming :-). This implementation originated in alt-ergo-zero but has been basically rewritten from scratch several times since.

type 'a t

Abstract type of vectors of 'a

val make : int -> 'a -> 'a t

make cap dummy creates a new vector filled with dummy. The vector is initially empty but its underlying array has capacity cap. dummy will stay alive as long as the vector

val create : unit -> 'a t
val to_list : 'a t -> 'a list

Returns the list of elements of the vector

val to_array : 'a t -> 'a array
val of_list : 'a list -> 'a t
val clear : 'a t -> unit

Set size to 0, doesn't free elements

val ensure_size : 'a t -> elt:'a -> int -> unit

ensure size is at least n

val ensure_size_with : 'a t -> (unit -> 'a) -> int -> unit

ensure size is at least n

val shrink : 'a t -> int -> unit

shrink vec sz resets size of vec to sz. Assumes sz >=0 && sz <= size vec

val pop_exn : 'a t -> 'a

Pop last element and return it.

  • raises Invalid_argument

    if the vector is empty

val pop : 'a t -> 'a option
val size : 'a t -> int
val is_empty : 'a t -> bool
val is_full : 'a t -> bool

Is the capacity of the vector equal to the number of its elements?

val push : 'a t -> 'a -> unit

Push element into the vector

val get : 'a t -> int -> 'a

get the element at the given index, or

  • raises Invalid_argument

    if the index is not valid

val set : 'a t -> int -> 'a -> unit

set the element at the given index, either already set or the first free slot if not (is_full vec), or

  • raises Invalid_argument

    if the index is not valid

val copy : 'a t -> 'a t

Fresh copy

val fast_remove : 'a t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val append : into:'a t -> 'a t -> unit

append ~into v pushes elements of v in the vector into

val prepend : 'a t -> into:'a t -> unit

prepend v ~into pushes all elements of v into into, at the beginning. consumes v.

val filter_in_place : ('a -> bool) -> 'a t -> unit

filter_in_place f v removes from v the elements that do not satisfy f

val sort : 'a t -> ('a -> 'a -> int) -> unit

Sort in place the array

val iter : f:('a -> unit) -> 'a t -> unit

Iterate on elements

val rev_iter : f:('a -> unit) -> 'a t -> unit
val to_iter : 'a t -> 'a Iter.t
val iteri : f:(int -> 'a -> unit) -> 'a t -> unit

Iterate on elements with their index

val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b

Fold over elements

val exists : ('a -> bool) -> 'a t -> bool

Does there exist an element that satisfies the predicate?

val for_all : ('a -> bool) -> 'a t -> bool

Do all elements satisfy the predicate?

val pp : - ?sep:string -> +Vec (sidekick.Sidekick_util.Vec)

Module Sidekick_util.Vec

Vectors

A resizable array, workhorse of imperative programming :-). This implementation originated in alt-ergo-zero but has been basically rewritten from scratch several times since.

type 'a t

Abstract type of vectors of 'a

val make : int -> 'a -> 'a t

make cap dummy creates a new vector filled with dummy. The vector is initially empty but its underlying array has capacity cap. dummy will stay alive as long as the vector

val create : unit -> 'a t
val to_list : 'a t -> 'a list

Returns the list of elements of the vector

val to_array : 'a t -> 'a array
val of_list : 'a list -> 'a t
val clear : 'a t -> unit

Set size to 0, doesn't free elements

val ensure_size : 'a t -> elt:'a -> int -> unit

ensure size is at least n

val ensure_size_with : 'a t -> (unit -> 'a) -> int -> unit

ensure size is at least n

val shrink : 'a t -> int -> unit

shrink vec sz resets size of vec to sz. Assumes sz >=0 && sz <= size vec

val pop_exn : 'a t -> 'a

Pop last element and return it.

  • raises Invalid_argument

    if the vector is empty

val pop : 'a t -> 'a option
val size : 'a t -> int
val is_empty : 'a t -> bool
val is_full : 'a t -> bool

Is the capacity of the vector equal to the number of its elements?

val push : 'a t -> 'a -> unit

Push element into the vector

val get : 'a t -> int -> 'a

get the element at the given index, or

  • raises Invalid_argument

    if the index is not valid

val set : 'a t -> int -> 'a -> unit

set the element at the given index, either already set or the first free slot if not (is_full vec), or

  • raises Invalid_argument

    if the index is not valid

val copy : 'a t -> 'a t

Fresh copy

val fast_remove : 'a t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val append : into:'a t -> 'a t -> unit

append ~into v pushes elements of v in the vector into

val prepend : 'a t -> into:'a t -> unit

prepend v ~into pushes all elements of v into into, at the beginning. consumes v.

val filter_in_place : ('a -> bool) -> 'a t -> unit

filter_in_place f v removes from v the elements that do not satisfy f

val sort : 'a t -> ('a -> 'a -> int) -> unit

Sort in place the array

val iter : f:('a -> unit) -> 'a t -> unit

Iterate on elements

val rev_iter : f:('a -> unit) -> 'a t -> unit
val to_iter : 'a t -> 'a Iter.t
val iteri : f:(int -> 'a -> unit) -> 'a t -> unit

Iterate on elements with their index

val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b

Fold over elements

val exists : ('a -> bool) -> 'a t -> bool

Does there exist an element that satisfies the predicate?

val for_all : ('a -> bool) -> 'a t -> bool

Do all elements satisfy the predicate?

val pp : + ?sep:string -> (Stdlib.Format.formatter -> 'a -> unit) -> Stdlib.Format.formatter -> 'a t -> - unit
\ No newline at end of file + unit
diff --git a/dev/sidekick/Sidekick_util/Vec_float/index.html b/dev/sidekick/Sidekick_util/Vec_float/index.html index 5bfa97f5..28299c6b 100644 --- a/dev/sidekick/Sidekick_util/Vec_float/index.html +++ b/dev/sidekick/Sidekick_util/Vec_float/index.html @@ -1,2 +1,2 @@ -Vec_float (sidekick.Sidekick_util.Vec_float)

Module Sidekick_util.Vec_float

Vectors of floats

These vectors are more optimized than Vec.

include Vec_sig.S with type elt := float
include Vec_sig.BASE with type elt := float
include Vec_sig.BASE_RO with type elt := float
type t
val size : t -> int
val get : t -> int -> float
val iter : f:(float -> unit) -> t -> unit
val iteri : f:(int -> float -> unit) -> t -> unit
val to_iter : t -> float Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> float -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (float -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> float
val set : t -> int -> float -> unit
val shrink : t -> int -> unit
include Vec_sig.EXTENSIONS with type t := t and type elt := float
val to_array : t -> float array
val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a
val pp : float CCFormat.printer -> t CCFormat.printer
\ No newline at end of file +Vec_float (sidekick.Sidekick_util.Vec_float)

Module Sidekick_util.Vec_float

Vectors of floats

These vectors are more optimized than Vec.

include Vec_sig.S with type elt := float
include Vec_sig.BASE with type elt := float
include Vec_sig.BASE_RO with type elt := float
type t
val size : t -> int
val get : t -> int -> float
val iter : f:(float -> unit) -> t -> unit
val iteri : f:(int -> float -> unit) -> t -> unit
val to_iter : t -> float Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> float -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (float -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> float
val set : t -> int -> float -> unit
val shrink : t -> int -> unit
include Vec_sig.EXTENSIONS with type t := t and type elt := float
val to_array : t -> float array
val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a
val pp : float CCFormat.printer -> t CCFormat.printer
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/argument-1-B/index.html b/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/argument-1-B/index.html index 43ae8641..2eb6ea48 100644 --- a/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/argument-1-B/index.html +++ b/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/argument-1-B/index.html @@ -1,2 +1,2 @@ -B (sidekick.Sidekick_util.Vec_sig.Make_extensions.B)

Parameter Make_extensions.B

type elt
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
\ No newline at end of file +B (sidekick.Sidekick_util.Vec_sig.Make_extensions.B)

Parameter Make_extensions.B

type elt
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/index.html b/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/index.html index 63730a58..7e027707 100644 --- a/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/index.html +++ b/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/index.html @@ -1,2 +1,2 @@ -Make_extensions (sidekick.Sidekick_util.Vec_sig.Make_extensions)

Module Vec_sig.Make_extensions

Parameters

module B : BASE_RO

Signature

val to_array : B.t -> B.elt array
val fold_left : ('a -> B.elt -> 'a) -> 'a -> B.t -> 'a
val pp : B.elt CCFormat.printer -> B.t CCFormat.printer
\ No newline at end of file +Make_extensions (sidekick.Sidekick_util.Vec_sig.Make_extensions)

Module Vec_sig.Make_extensions

Parameters

module B : BASE_RO

Signature

val to_array : B.t -> B.elt array
val fold_left : ('a -> B.elt -> 'a) -> 'a -> B.t -> 'a
val pp : B.elt CCFormat.printer -> B.t CCFormat.printer
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/index.html b/dev/sidekick/Sidekick_util/Vec_sig/index.html index 073cee99..88b37059 100644 --- a/dev/sidekick/Sidekick_util/Vec_sig/index.html +++ b/dev/sidekick/Sidekick_util/Vec_sig/index.html @@ -1,4 +1,4 @@ -Vec_sig (sidekick.Sidekick_util.Vec_sig)

Module Sidekick_util.Vec_sig

module type BASE_RO = sig ... end

Basics

module type BASE = sig ... end
module type EXTENSIONS = sig ... end
module type S = sig ... end
module Make_extensions +Vec_sig (sidekick.Sidekick_util.Vec_sig)

Module Sidekick_util.Vec_sig

module type BASE_RO = sig ... end

Basics

module type BASE = sig ... end
module type EXTENSIONS = sig ... end
module type S = sig ... end
module Make_extensions (B : BASE_RO) : - EXTENSIONS with type t := B.t and type elt := B.elt
\ No newline at end of file + EXTENSIONS with type t := B.t and type elt := B.elt
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE/index.html b/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE/index.html index 0f0af8ab..0b62ad16 100644 --- a/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE/index.html +++ b/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE/index.html @@ -1,2 +1,2 @@ -BASE (sidekick.Sidekick_util.Vec_sig.BASE)

Module type Vec_sig.BASE

include BASE_RO
type elt
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (elt -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
\ No newline at end of file +BASE (sidekick.Sidekick_util.Vec_sig.BASE)

Module type Vec_sig.BASE

include BASE_RO
type elt
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (elt -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE_RO/index.html b/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE_RO/index.html index bdc5ebd1..1c7fdfa1 100644 --- a/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE_RO/index.html +++ b/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE_RO/index.html @@ -1,2 +1,2 @@ -BASE_RO (sidekick.Sidekick_util.Vec_sig.BASE_RO)

Module type Vec_sig.BASE_RO

Basics

type elt
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
\ No newline at end of file +BASE_RO (sidekick.Sidekick_util.Vec_sig.BASE_RO)

Module type Vec_sig.BASE_RO

Basics

type elt
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/module-type-EXTENSIONS/index.html b/dev/sidekick/Sidekick_util/Vec_sig/module-type-EXTENSIONS/index.html index 9b5ed8eb..9bd94fe3 100644 --- a/dev/sidekick/Sidekick_util/Vec_sig/module-type-EXTENSIONS/index.html +++ b/dev/sidekick/Sidekick_util/Vec_sig/module-type-EXTENSIONS/index.html @@ -1,2 +1,2 @@ -EXTENSIONS (sidekick.Sidekick_util.Vec_sig.EXTENSIONS)

Module type Vec_sig.EXTENSIONS

type elt
type t
val to_array : t -> elt array
val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file +EXTENSIONS (sidekick.Sidekick_util.Vec_sig.EXTENSIONS)

Module type Vec_sig.EXTENSIONS

type elt
type t
val to_array : t -> elt array
val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/module-type-S/index.html b/dev/sidekick/Sidekick_util/Vec_sig/module-type-S/index.html index bed1d678..ca7c50ec 100644 --- a/dev/sidekick/Sidekick_util/Vec_sig/module-type-S/index.html +++ b/dev/sidekick/Sidekick_util/Vec_sig/module-type-S/index.html @@ -1,2 +1,2 @@ -S (sidekick.Sidekick_util.Vec_sig.S)

Module type Vec_sig.S

include BASE
include BASE_RO
type elt
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (elt -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include EXTENSIONS with type t := t and type elt := elt
val to_array : t -> elt array
val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file +S (sidekick.Sidekick_util.Vec_sig.S)

Module type Vec_sig.S

include BASE
include BASE_RO
type elt
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:(elt -> unit) -> t -> unit
val iteri : f:(int -> elt -> unit) -> t -> unit
val to_iter : t -> elt Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (elt -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include EXTENSIONS with type t := t and type elt := elt
val to_array : t -> elt array
val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
diff --git a/dev/sidekick/Sidekick_util/Veci/index.html b/dev/sidekick/Sidekick_util/Veci/index.html index 527de74b..2d108cb3 100644 --- a/dev/sidekick/Sidekick_util/Veci/index.html +++ b/dev/sidekick/Sidekick_util/Veci/index.html @@ -1,2 +1,2 @@ -Veci (sidekick.Sidekick_util.Veci)

Module Sidekick_util.Veci

Vectors of int32 integers

These vectors are more optimized than Vec.

include Vec_sig.S with type elt := int
include Vec_sig.BASE with type elt := int
include Vec_sig.BASE_RO with type elt := int
type t
val size : t -> int
val get : t -> int -> int
val iter : f:(int -> unit) -> t -> unit
val iteri : f:(int -> int -> unit) -> t -> unit
val to_iter : t -> int Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> int -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (int -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> int
val set : t -> int -> int -> unit
val shrink : t -> int -> unit
include Vec_sig.EXTENSIONS with type t := t and type elt := int
val to_array : t -> int array
val fold_left : ('a -> int -> 'a) -> 'a -> t -> 'a
val pp : int CCFormat.printer -> t CCFormat.printer
val push_i32 : t -> int32 -> unit
val get_i32 : t -> int -> int32
val set_i32 : t -> int -> int32 -> unit
\ No newline at end of file +Veci (sidekick.Sidekick_util.Veci)

Module Sidekick_util.Veci

Vectors of int32 integers

These vectors are more optimized than Vec.

include Vec_sig.S with type elt := int
include Vec_sig.BASE with type elt := int
include Vec_sig.BASE_RO with type elt := int
type t
val size : t -> int
val get : t -> int -> int
val iter : f:(int -> unit) -> t -> unit
val iteri : f:(int -> int -> unit) -> t -> unit
val to_iter : t -> int Iter.t
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> int -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : (int -> bool) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> int
val set : t -> int -> int -> unit
val shrink : t -> int -> unit
include Vec_sig.EXTENSIONS with type t := t and type elt := int
val to_array : t -> int array
val fold_left : ('a -> int -> 'a) -> 'a -> t -> 'a
val pp : int CCFormat.printer -> t CCFormat.printer
val push_i32 : t -> int32 -> unit
val get_i32 : t -> int -> int32
val set_i32 : t -> int -> int32 -> unit
diff --git a/dev/sidekick/Sidekick_util/index.html b/dev/sidekick/Sidekick_util/index.html index dcc164c6..da1e18c4 100644 --- a/dev/sidekick/Sidekick_util/index.html +++ b/dev/sidekick/Sidekick_util/index.html @@ -1,2 +1,2 @@ -Sidekick_util (sidekick.Sidekick_util)

Module Sidekick_util

module Fmt = CCFormat
module Util : sig ... end
module Vec : sig ... end

Vectors

module Veci : sig ... end

Vectors of int32 integers

module Vec_float : sig ... end

Vectors of floats

module Vec_sig : sig ... end
module Bitvec : sig ... end

Bitvector.

module Int_id : sig ... end

Integer-based identifiers.

module Int_tbl = Util.Int_tbl
module Int_set = Util.Int_set
module Int_map = Util.Int_map
module Event : sig ... end

Event pattern.

module Backtrack_stack : sig ... end
module Backtrackable_tbl : sig ... end
module Backtrackable_ref : sig ... end
module Log : sig ... end

Logging function, for debugging

module Error : sig ... end
module Bag : sig ... end
module Stat : sig ... end
module Hash : sig ... end
module Profile : sig ... end

Profiling probes.

module Chunk_stack : sig ... end

Manage a list of chunks.

module Ser_value : sig ... end

Serialization representation.

module Ser_decode : sig ... end

Decoders for Ser_value.

val let@ : ('a -> 'b) -> 'c -> 'd
\ No newline at end of file +Sidekick_util (sidekick.Sidekick_util)

Module Sidekick_util

module Fmt = CCFormat
module Util : sig ... end
module Vec : sig ... end

Vectors

module Veci : sig ... end

Vectors of int32 integers

module Vec_float : sig ... end

Vectors of floats

module Vec_sig : sig ... end
module Bitvec : sig ... end

Bitvector.

module Int_id : sig ... end

Integer-based identifiers.

module Int_tbl = Util.Int_tbl
module Int_set = Util.Int_set
module Int_map = Util.Int_map
module Event : sig ... end

Event pattern.

module Backtrack_stack : sig ... end
module Backtrackable_tbl : sig ... end
module Backtrackable_ref : sig ... end
module Log : sig ... end

Logging function, for debugging

module Error : sig ... end
module Bag : sig ... end
module Stat : sig ... end
module Hash : sig ... end
module Profile : sig ... end
module Chunk_stack : sig ... end

Manage a list of chunks.

module Ser_value : sig ... end

Serialization representation.

module Ser_decode : sig ... end

Decoders for Ser_value.

val let@ : ('a -> 'b) -> 'a -> 'b
diff --git a/dev/sidekick/Sidekick_zarith/.dummy b/dev/sidekick/Sidekick_zarith/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_zarith/Int/index.html b/dev/sidekick/Sidekick_zarith/Int/index.html index 5b366a5e..a4e5ad8a 100644 --- a/dev/sidekick/Sidekick_zarith/Int/index.html +++ b/dev/sidekick/Sidekick_zarith/Int/index.html @@ -1,2 +1,2 @@ -Int (sidekick.Sidekick_zarith.Int)

Module Sidekick_zarith.Int

include Sidekick_arith.INT with type t = Z.t
include Sidekick_arith.NUM with type t = Z.t
type t = Z.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
val sqrt : t -> t
val divexact : t -> t -> t
val (/) : t -> t -> t
val ediv : t -> t -> t

Euclidian division

val rem : t -> t -> t
val probab_prime : t -> bool
val pow : t -> int -> t
\ No newline at end of file +Int (sidekick.Sidekick_zarith.Int)

Module Sidekick_zarith.Int

include Sidekick_arith.INT with type t = Z.t
include Sidekick_arith.NUM with type t = Z.t
type t = Z.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
val sqrt : t -> t
val divexact : t -> t -> t
val (/) : t -> t -> t
val ediv : t -> t -> t

Euclidian division

val rem : t -> t -> t
val probab_prime : t -> bool
val pow : t -> int -> t
diff --git a/dev/sidekick/Sidekick_zarith/Rational/index.html b/dev/sidekick/Sidekick_zarith/Rational/index.html index 66693cd5..47ba662b 100644 --- a/dev/sidekick/Sidekick_zarith/Rational/index.html +++ b/dev/sidekick/Sidekick_zarith/Rational/index.html @@ -1,2 +1,2 @@ -Rational (sidekick.Sidekick_zarith.Rational)

Module Sidekick_zarith.Rational

include Sidekick_arith.NUM with type t = Q.t
type t = Q.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Rational (sidekick.Sidekick_zarith.Rational)

Module Sidekick_zarith.Rational

include Sidekick_arith.NUM with type t = Q.t
type t = Q.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val to_string : t -> string
val of_string : string -> t option
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

diff --git a/dev/sidekick/Sidekick_zarith/index.html b/dev/sidekick/Sidekick_zarith/index.html index 33548bc8..a640021c 100644 --- a/dev/sidekick/Sidekick_zarith/index.html +++ b/dev/sidekick/Sidekick_zarith/index.html @@ -1,3 +1,3 @@ -Sidekick_zarith (sidekick.Sidekick_zarith)

Module Sidekick_zarith

module Int : Sidekick_arith.INT_FULL with type t = Z.t
module Rational : - Sidekick_arith.RATIONAL with type t = Q.t and type bigint = Z.t
\ No newline at end of file +Sidekick_zarith (sidekick.Sidekick_zarith)

Module Sidekick_zarith

module Int : Sidekick_arith.INT_FULL with type t = Z.t
module Rational : + Sidekick_arith.RATIONAL with type t = Q.t and type bigint = Z.t
diff --git a/dev/sidekick/index.html b/dev/sidekick/index.html index 366707e9..541bb585 100644 --- a/dev/sidekick/index.html +++ b/dev/sidekick/index.html @@ -1,2 +1,2 @@ -index (sidekick.index)

sidekick index

Library sidekick.abstract-solver

The entry point of this library is the module: Sidekick_abstract_solver.

Library sidekick.arith

The entry point of this library is the module: Sidekick_arith.

Library sidekick.bencode

The entry point of this library is the module: Sidekick_bencode.

Library sidekick.cc

The entry point of this library is the module: Sidekick_cc.

Library sidekick.cc.plugin

The entry point of this library is the module: Sidekick_cc_plugin.

Library sidekick.core

The entry point of this library is the module: Sidekick_core.

Library sidekick.core-logic

The entry point of this library is the module: Sidekick_core_logic.

Library sidekick.drup

The entry point of this library is the module: Sidekick_drup.

Library sidekick.memtrace

The entry point of this library is the module: Sidekick_memtrace.

Library sidekick.mini-cc

The entry point of this library is the module: Sidekick_mini_cc.

Library sidekick.proof

The entry point of this library is the module: Sidekick_proof.

Library sidekick.quip

The entry point of this library is the module: Sidekick_quip.

Library sidekick.sat

The entry point of this library is the module: Sidekick_sat.

Library sidekick.sigs

The entry point of this library is the module: Sidekick_sigs.

Library sidekick.simplex

The entry point of this library is the module: Sidekick_simplex.

Library sidekick.simplify

The entry point of this library is the module: Sidekick_simplify.

Library sidekick.smt-solver

The entry point of this library is the module: Sidekick_smt_solver.

Library sidekick.tef

The entry point of this library is the module: Sidekick_tef.

Library sidekick.th-bool-dyn

The entry point of this library is the module: Sidekick_th_bool_dyn.

Library sidekick.th-bool-static

The entry point of this library is the module: Sidekick_th_bool_static.

Library sidekick.th-cstor

The entry point of this library is the module: Sidekick_th_cstor.

Library sidekick.th-data

The entry point of this library is the module: Sidekick_th_data.

Library sidekick.th-lra

The entry point of this library is the module: Sidekick_th_lra.

Library sidekick.th-ty-unin

The entry point of this library is the module: Sidekick_th_ty_unin.

Library sidekick.trace

The entry point of this library is the module: Sidekick_trace.

Library sidekick.util

The entry point of this library is the module: Sidekick_util.

Library sidekick.zarith

The entry point of this library is the module: Sidekick_zarith.

\ No newline at end of file +index (sidekick.index)

sidekick index

Library sidekick.abstract-solver

The entry point of this library is the module: Sidekick_abstract_solver.

Library sidekick.arith

The entry point of this library is the module: Sidekick_arith.

Library sidekick.bencode

The entry point of this library is the module: Sidekick_bencode.

Library sidekick.cc

The entry point of this library is the module: Sidekick_cc.

Library sidekick.cc.plugin

The entry point of this library is the module: Sidekick_cc_plugin.

Library sidekick.core

The entry point of this library is the module: Sidekick_core.

Library sidekick.core-logic

The entry point of this library is the module: Sidekick_core_logic.

Library sidekick.drup

The entry point of this library is the module: Sidekick_drup.

Library sidekick.memtrace

The entry point of this library is the module: Sidekick_memtrace.

Library sidekick.mini-cc

The entry point of this library is the module: Sidekick_mini_cc.

Library sidekick.proof

The entry point of this library is the module: Sidekick_proof.

Library sidekick.quip

The entry point of this library is the module: Sidekick_quip.

Library sidekick.sat

The entry point of this library is the module: Sidekick_sat.

Library sidekick.sigs

The entry point of this library is the module: Sidekick_sigs.

Library sidekick.simplex

The entry point of this library is the module: Sidekick_simplex.

Library sidekick.simplify

The entry point of this library is the module: Sidekick_simplify.

Library sidekick.smt-solver

The entry point of this library is the module: Sidekick_smt_solver.

Library sidekick.th-bool-dyn

The entry point of this library is the module: Sidekick_th_bool_dyn.

Library sidekick.th-bool-static

The entry point of this library is the module: Sidekick_th_bool_static.

Library sidekick.th-cstor

The entry point of this library is the module: Sidekick_th_cstor.

Library sidekick.th-data

The entry point of this library is the module: Sidekick_th_data.

Library sidekick.th-lra

The entry point of this library is the module: Sidekick_th_lra.

Library sidekick.th-ty-unin

The entry point of this library is the module: Sidekick_th_ty_unin.

Library sidekick.trace

The entry point of this library is the module: Sidekick_trace.

Library sidekick.util

The entry point of this library is the module: Sidekick_util.

Library sidekick.zarith

The entry point of this library is the module: Sidekick_zarith.

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 literal 0 HcmV?d00001 diff --git a/dev/odoc.support/fonts/fira-sans-v17-latin-700italic.woff2 b/dev/odoc.support/fonts/fira-sans-v17-latin-700italic.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..bdf8f5f9844d5d875b915e68ff4b4965df337049 GIT binary patch literal 26072 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 literal 0 HcmV?d00001 diff --git a/dev/odoc.support/fonts/fira-sans-v17-latin-italic.woff2 b/dev/odoc.support/fonts/fira-sans-v17-latin-italic.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..b9619dd5d7e7d0fd16d0cd692437b3a76057ad80 GIT binary patch literal 24936 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