From aebaaf56af8770408f69c4548d118dc3bc1b894c Mon Sep 17 00:00:00 2001 From: c-cube Date: Sun, 4 Jul 2021 02:50:03 +0000 Subject: [PATCH] deploy: 6578ea91362b7a5bf67328d9f56998cdc769c767 --- dev/sidekick-base/Sidekick_base/Arg/Term/index.html | 2 +- dev/sidekick-base/Sidekick_base/Arg/Ty/index.html | 2 +- dev/sidekick-base/Sidekick_base/Arg/index.html | 2 +- dev/sidekick-base/Sidekick_base/Base_types/Term/index.html | 2 +- dev/sidekick-base/Sidekick_base/Base_types/Ty/index.html | 2 +- dev/sidekick-base/Sidekick_base/Form/Funs/index.html | 2 ++ dev/sidekick-base/Sidekick_base/Form/Gensym/index.html | 2 ++ dev/sidekick-base/Sidekick_base/Form/index.html | 2 ++ dev/sidekick-base/Sidekick_base/index.html | 2 +- dev/sidekick-base/Sidekick_base__/Base_types/Term/index.html | 2 +- dev/sidekick-base/Sidekick_base__/Base_types/Ty/index.html | 2 +- dev/sidekick-base/Sidekick_base__/Form/Funs/index.html | 2 ++ dev/sidekick-base/Sidekick_base__/Form/Gensym/index.html | 2 ++ dev/sidekick-base/Sidekick_base__/Form/index.html | 2 ++ dev/sidekick-base/Sidekick_base__/index.html | 2 +- dev/sidekick-base/Sidekick_base__Base_types/Term/index.html | 2 +- dev/sidekick-base/Sidekick_base__Base_types/Ty/index.html | 2 +- .../Sidekick_base__Form}/.dune-keep | 0 dev/sidekick-base/Sidekick_base__Form/Funs/index.html | 2 ++ dev/sidekick-base/Sidekick_base__Form/Gensym/index.html | 2 ++ dev/sidekick-base/Sidekick_base__Form/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/.dune-keep | 0 dev/sidekick-base/Sidekick_base_solver/Solver/Atom/index.html | 2 ++ .../Sidekick_base_solver/Solver/Lit/T/Fun/index.html | 2 ++ .../Sidekick_base_solver/Solver/Lit/T/Term/Tbl/index.html | 2 ++ .../Sidekick_base_solver/Solver/Lit/T/Term/index.html | 2 ++ .../Sidekick_base_solver/Solver/Lit/T/Ty/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/Lit/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/Model/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/P/Quip/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/P/index.html | 2 ++ .../Sidekick_base_solver/Solver/Pre_proof/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/Lit/T/Fun/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/Lit/T/Term/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/Lit/T/Ty/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/Lit/T/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/Lit/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/P/Quip/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/P/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/T/Fun/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/T/Term/Tbl/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/T/Term/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/T/Ty/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/T/index.html | 2 ++ .../Solver/Solver_internal/CC/Actions/index.html | 2 ++ .../Solver/Solver_internal/CC/Debug_/index.html | 2 ++ .../Solver/Solver_internal/CC/Expl/index.html | 2 ++ .../Solver/Solver_internal/CC/Lit/T/Fun/index.html | 2 ++ .../Solver/Solver_internal/CC/Lit/T/Term/Tbl/index.html | 2 ++ .../Solver/Solver_internal/CC/Lit/T/Term/index.html | 2 ++ .../Solver/Solver_internal/CC/Lit/T/Ty/index.html | 2 ++ .../Solver/Solver_internal/CC/Lit/T/index.html | 2 ++ .../Solver/Solver_internal/CC/Lit/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/CC/N/index.html | 2 ++ .../Solver/Solver_internal/CC/P/Quip/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/CC/P/index.html | 2 ++ .../Solver/Solver_internal/CC/T/Fun/index.html | 2 ++ .../Solver/Solver_internal/CC/T/Term/Tbl/index.html | 2 ++ .../Solver/Solver_internal/CC/T/Term/index.html | 2 ++ .../Solver/Solver_internal/CC/T/Ty/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/CC/T/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/CC/index.html | 2 ++ .../Solver/Solver_internal/Lit/T/Fun/index.html | 2 ++ .../Solver/Solver_internal/Lit/T/Term/Tbl/index.html | 2 ++ .../Solver/Solver_internal/Lit/T/Term/index.html | 2 ++ .../Solver/Solver_internal/Lit/T/Ty/index.html | 2 ++ .../Solver/Solver_internal/Lit/T/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/Lit/index.html | 2 ++ .../Solver/Solver_internal/P/Quip/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/P/index.html | 2 ++ .../Solver/Solver_internal/Simplify/index.html | 2 ++ .../Solver/Solver_internal/T/Fun/index.html | 2 ++ .../Solver/Solver_internal/T/Term/Tbl/index.html | 2 ++ .../Solver/Solver_internal/T/Term/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/T/Ty/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/T/index.html | 2 ++ .../Sidekick_base_solver/Solver/Solver_internal/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/T/Fun/index.html | 2 ++ .../Sidekick_base_solver/Solver/T/Term/Tbl/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/T/Ty/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/T/index.html | 2 ++ .../Sidekick_base_solver/Solver/Unknown/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver/index.html | 2 ++ .../Sidekick_base_solver/Solver/module-type-THEORY/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Solver_arg/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/Gensym/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Atom/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Lit/T/Fun/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/Tbl/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Lit/T/Ty/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Lit/T/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Lit/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Model/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/P/Quip/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Pre_proof/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html | 2 ++ .../A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html | 2 ++ .../A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/Lit/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/P/Quip/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/P/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/T/Fun/index.html | 2 ++ .../A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/T/Term/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/T/Ty/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/T/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Actions/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Debug_/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Expl/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Lit/T/Fun/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Lit/T/Term/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Lit/T/Ty/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Lit/T/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/Lit/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/N/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/P/Quip/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/P/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/T/Fun/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/T/Term/Tbl/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/T/Term/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/T/Ty/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/T/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/CC/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/Lit/T/Fun/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/Lit/T/Term/Tbl/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/Lit/T/Term/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/Lit/T/Ty/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/Lit/T/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/Lit/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/P/Quip/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/P/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/Simplify/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/T/Fun/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/T/Term/Tbl/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/T/Term/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/T/Ty/index.html | 2 ++ .../Th_bool/A/S/Solver_internal/T/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Solver_internal/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/T/Fun/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/T/Term/Tbl/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/T/Term/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/T/Ty/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/index.html | 2 ++ .../Sidekick_base_solver/Th_bool/A/S/Unknown/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/index.html | 2 ++ .../Th_bool/A/S/module-type-THEORY/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_bool/A/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_bool/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/Cstor/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Atom/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Lit/T/Fun/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Lit/T/Term/Tbl/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Lit/T/Term/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Lit/T/Ty/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Lit/T/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Lit/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Model/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/P/Quip/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Pre_proof/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html | 2 ++ .../A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html | 2 ++ .../A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/Lit/T/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/Lit/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/P/Quip/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/P/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/T/Fun/index.html | 2 ++ .../A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/T/Term/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/T/Ty/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/T/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Actions/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Debug_/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Expl/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Lit/T/Fun/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Lit/T/Term/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Lit/T/Ty/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Lit/T/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/Lit/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/N/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/P/Quip/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/P/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/T/Fun/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/T/Term/Tbl/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/T/Term/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/T/Ty/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/T/index.html | 2 ++ .../Th_data/A/S/Solver_internal/CC/index.html | 2 ++ .../Th_data/A/S/Solver_internal/Lit/T/Fun/index.html | 2 ++ .../Th_data/A/S/Solver_internal/Lit/T/Term/Tbl/index.html | 2 ++ .../Th_data/A/S/Solver_internal/Lit/T/Term/index.html | 2 ++ .../Th_data/A/S/Solver_internal/Lit/T/Ty/index.html | 2 ++ .../Th_data/A/S/Solver_internal/Lit/T/index.html | 2 ++ .../Th_data/A/S/Solver_internal/Lit/index.html | 2 ++ .../Th_data/A/S/Solver_internal/P/Quip/index.html | 2 ++ .../Th_data/A/S/Solver_internal/P/index.html | 2 ++ .../Th_data/A/S/Solver_internal/Simplify/index.html | 2 ++ .../Th_data/A/S/Solver_internal/T/Fun/index.html | 2 ++ .../Th_data/A/S/Solver_internal/T/Term/Tbl/index.html | 2 ++ .../Th_data/A/S/Solver_internal/T/Term/index.html | 2 ++ .../Th_data/A/S/Solver_internal/T/Ty/index.html | 2 ++ .../Th_data/A/S/Solver_internal/T/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Solver_internal/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/T/Fun/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/T/Term/Tbl/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/T/Term/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/T/Ty/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/index.html | 2 ++ .../Sidekick_base_solver/Th_data/A/S/Unknown/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/index.html | 2 ++ .../Th_data/A/S/module-type-THEORY/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_data/A/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_data/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/Gensym/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Atom/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Lit/T/Fun/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/Tbl/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Lit/T/Ty/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Lit/T/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Lit/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Model/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/P/Quip/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Pre_proof/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html | 2 ++ .../A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/Lit/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/P/Quip/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/P/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/T/Fun/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/T/Term/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/T/Ty/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/T/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Actions/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Debug_/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Expl/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Lit/T/Fun/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Lit/T/Term/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Lit/T/Ty/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Lit/T/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/Lit/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/N/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/P/Quip/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/P/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/T/Fun/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/T/Term/Tbl/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/T/Term/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/T/Ty/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/T/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/CC/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/Lit/T/Fun/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/Lit/T/Term/Tbl/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/Lit/T/Term/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/Lit/T/Ty/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/Lit/T/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/Lit/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/P/Quip/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/P/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/Simplify/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/T/Fun/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/T/Term/Tbl/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/T/Term/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/T/Ty/index.html | 2 ++ .../Th_lra/A/S/Solver_internal/T/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Solver_internal/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/T/Fun/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/T/Term/Tbl/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/T/Term/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/T/Ty/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/index.html | 2 ++ .../Sidekick_base_solver/Th_lra/A/S/Unknown/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/index.html | 2 ++ .../Th_lra/A/S/module-type-THEORY/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_lra/A/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/Th_lra/index.html | 2 ++ dev/sidekick-base/Sidekick_base_solver/index.html | 2 ++ dev/sidekick-base/index.html | 2 +- .../Process/Solver/Solver_internal/CC/index.html | 2 +- .../Process/Solver/Solver_internal/Simplify/index.html | 2 +- .../Sidekick_smtlib/Process/Solver/Solver_internal/index.html | 2 +- .../Sidekick_smtlib/Process/Solver/T/Term/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Ty/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib/Process/Solver/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib/Process/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__/Form/Funs/index.html | 2 -- dev/sidekick-bin/Sidekick_smtlib__/Form/Gensym/index.html | 2 -- dev/sidekick-bin/Sidekick_smtlib__/Form/index.html | 2 -- .../Process/Solver/Solver_internal/CC/index.html | 2 +- .../Process/Solver/Solver_internal/Simplify/index.html | 2 +- .../Sidekick_smtlib__/Process/Solver/Solver_internal/index.html | 2 +- .../Sidekick_smtlib__/Process/Solver/T/Term/index.html | 2 +- .../Sidekick_smtlib__/Process/Solver/T/Ty/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__/Process/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__/Typecheck/Ctx/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__Form/Funs/index.html | 2 -- dev/sidekick-bin/Sidekick_smtlib__Form/Gensym/index.html | 2 -- dev/sidekick-bin/Sidekick_smtlib__Form/index.html | 2 -- .../Solver/Solver_internal/CC/index.html | 2 +- .../Solver/Solver_internal/Simplify/index.html | 2 +- .../Sidekick_smtlib__Process/Solver/Solver_internal/index.html | 2 +- .../Sidekick_smtlib__Process/Solver/T/Term/index.html | 2 +- .../Sidekick_smtlib__Process/Solver/T/Ty/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__Process/Solver/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__Process/index.html | 2 +- dev/sidekick-bin/Sidekick_smtlib__Typecheck/Ctx/index.html | 2 +- .../Sidekick_arith_lra/Make/argument-1-A/Gensym/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/CC/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/Simplify/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/index.html | 2 +- .../Sidekick_arith_lra/Make/argument-1-A/S/T/Term/index.html | 2 +- .../Sidekick_arith_lra/Make/argument-1-A/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/index.html | 2 +- dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/index.html | 2 +- dev/sidekick/Sidekick_arith_lra/Make/index.html | 2 +- .../Sidekick_arith_lra/module-type-ARG/Gensym/index.html | 2 +- .../module-type-ARG/S/Solver_internal/CC/index.html | 2 +- .../module-type-ARG/S/Solver_internal/Simplify/index.html | 2 +- .../module-type-ARG/S/Solver_internal/index.html | 2 +- .../Sidekick_arith_lra/module-type-ARG/S/T/Term/index.html | 2 +- .../Sidekick_arith_lra/module-type-ARG/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/index.html | 2 +- dev/sidekick/Sidekick_arith_lra/module-type-ARG/index.html | 2 +- .../Sidekick_arith_lra/module-type-S/A/Gensym/index.html | 2 +- .../module-type-S/A/S/Solver_internal/CC/index.html | 2 +- .../module-type-S/A/S/Solver_internal/Simplify/index.html | 2 +- .../module-type-S/A/S/Solver_internal/index.html | 2 +- .../Sidekick_arith_lra/module-type-S/A/S/T/Term/index.html | 2 +- .../Sidekick_arith_lra/module-type-S/A/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/index.html | 2 +- dev/sidekick/Sidekick_arith_lra/module-type-S/A/index.html | 2 +- dev/sidekick/Sidekick_arith_lra/module-type-S/index.html | 2 +- dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Term/index.html | 2 +- dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_cc/Make/index.html | 2 +- dev/sidekick/Sidekick_cc/module-type-S/T/Term/index.html | 2 +- dev/sidekick/Sidekick_cc/module-type-S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_cc/module-type-S/index.html | 2 +- .../Sidekick_core/Monoid_of_repr/argument-1-M/SI/CC/index.html | 2 +- .../Monoid_of_repr/argument-1-M/SI/Simplify/index.html | 2 +- .../Monoid_of_repr/argument-1-M/SI/T/Term/index.html | 2 +- .../Monoid_of_repr/argument-1-M/SI/T/Ty/index.html | 2 +- .../Sidekick_core/Monoid_of_repr/argument-1-M/SI/index.html | 2 +- .../Sidekick_core/module-type-CC_ACTIONS/T/Term/index.html | 2 +- .../Sidekick_core/module-type-CC_ACTIONS/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Term/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-CC_S/T/Term/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-CC_S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-CC_S/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-LIT/T/Term/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-LIT/T/Ty/index.html | 2 +- .../Sidekick_core/module-type-MONOID_ARG/SI/CC/index.html | 2 +- .../Sidekick_core/module-type-MONOID_ARG/SI/Simplify/index.html | 2 +- .../Sidekick_core/module-type-MONOID_ARG/SI/T/Term/index.html | 2 +- .../Sidekick_core/module-type-MONOID_ARG/SI/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/index.html | 2 +- .../module-type-SOLVER/Solver_internal/CC/index.html | 2 +- .../module-type-SOLVER/Solver_internal/Simplify/index.html | 2 +- .../Sidekick_core/module-type-SOLVER/Solver_internal/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-SOLVER/T/Term/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-SOLVER/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-SOLVER/index.html | 2 +- .../Sidekick_core/module-type-SOLVER_INTERNAL/CC/index.html | 2 +- .../module-type-SOLVER_INTERNAL/Simplify/index.html | 2 +- .../Sidekick_core/module-type-SOLVER_INTERNAL/T/Term/index.html | 2 +- .../Sidekick_core/module-type-SOLVER_INTERNAL/T/Ty/index.html | 2 +- .../Sidekick_core/module-type-SOLVER_INTERNAL/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-TERM/Term/index.html | 2 +- dev/sidekick/Sidekick_core/module-type-TERM/Ty/index.html | 2 +- .../Sidekick_mini_cc/Make/argument-1-A/T/Term/index.html | 2 +- dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_mini_cc/Make/index.html | 2 +- dev/sidekick/Sidekick_mini_cc/index.html | 2 +- dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Term/index.html | 2 +- dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_mini_cc/module-type-S/index.html | 2 +- .../Sidekick_msat_solver/Make/Solver_internal/CC/index.html | 2 +- .../Make/Solver_internal/Simplify/index.html | 2 +- .../Sidekick_msat_solver/Make/Solver_internal/index.html | 2 +- .../Sidekick_msat_solver/Make/argument-1-A/T/Term/index.html | 2 +- .../Sidekick_msat_solver/Make/argument-1-A/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_msat_solver/Make/index.html | 2 +- .../Sidekick_msat_solver/module-type-ARG/T/Term/index.html | 2 +- .../Sidekick_msat_solver/module-type-ARG/T/Ty/index.html | 2 +- .../module-type-S/Solver_internal/CC/index.html | 2 +- .../module-type-S/Solver_internal/Simplify/index.html | 2 +- .../module-type-S/Solver_internal/index.html | 2 +- .../Sidekick_msat_solver/module-type-S/T/Term/index.html | 2 +- dev/sidekick/Sidekick_msat_solver/module-type-S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_msat_solver/module-type-S/index.html | 2 +- .../Sidekick_th_bool_static/Make/argument-1-A/Gensym/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/CC/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/Simplify/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/index.html | 2 +- .../Make/argument-1-A/S/T/Term/index.html | 2 +- .../Sidekick_th_bool_static/Make/argument-1-A/S/T/Ty/index.html | 2 +- .../Sidekick_th_bool_static/Make/argument-1-A/S/index.html | 2 +- .../Sidekick_th_bool_static/Make/argument-1-A/index.html | 2 +- dev/sidekick/Sidekick_th_bool_static/Make/index.html | 2 +- .../Sidekick_th_bool_static/module-type-ARG/Gensym/index.html | 2 +- .../module-type-ARG/S/Solver_internal/CC/index.html | 2 +- .../module-type-ARG/S/Solver_internal/Simplify/index.html | 2 +- .../module-type-ARG/S/Solver_internal/index.html | 2 +- .../Sidekick_th_bool_static/module-type-ARG/S/T/Term/index.html | 2 +- .../Sidekick_th_bool_static/module-type-ARG/S/T/Ty/index.html | 2 +- .../Sidekick_th_bool_static/module-type-ARG/S/index.html | 2 +- dev/sidekick/Sidekick_th_bool_static/module-type-ARG/index.html | 2 +- .../Sidekick_th_bool_static/module-type-S/A/Gensym/index.html | 2 +- .../module-type-S/A/S/Solver_internal/CC/index.html | 2 +- .../module-type-S/A/S/Solver_internal/Simplify/index.html | 2 +- .../module-type-S/A/S/Solver_internal/index.html | 2 +- .../Sidekick_th_bool_static/module-type-S/A/S/T/Term/index.html | 2 +- .../Sidekick_th_bool_static/module-type-S/A/S/T/Ty/index.html | 2 +- .../Sidekick_th_bool_static/module-type-S/A/S/index.html | 2 +- dev/sidekick/Sidekick_th_bool_static/module-type-S/A/index.html | 2 +- dev/sidekick/Sidekick_th_bool_static/module-type-S/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/CC/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/Simplify/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/index.html | 2 +- .../Sidekick_th_cstor/Make/argument-1-A/S/T/Term/index.html | 2 +- .../Sidekick_th_cstor/Make/argument-1-A/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/index.html | 2 +- .../module-type-ARG/S/Solver_internal/CC/index.html | 2 +- .../module-type-ARG/S/Solver_internal/Simplify/index.html | 2 +- .../module-type-ARG/S/Solver_internal/index.html | 2 +- .../Sidekick_th_cstor/module-type-ARG/S/T/Term/index.html | 2 +- .../Sidekick_th_cstor/module-type-ARG/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/index.html | 2 +- .../module-type-S/A/S/Solver_internal/CC/index.html | 2 +- .../module-type-S/A/S/Solver_internal/Simplify/index.html | 2 +- .../module-type-S/A/S/Solver_internal/index.html | 2 +- .../Sidekick_th_cstor/module-type-S/A/S/T/Term/index.html | 2 +- .../Sidekick_th_cstor/module-type-S/A/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/CC/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/Simplify/index.html | 2 +- .../Make/argument-1-A/S/Solver_internal/index.html | 2 +- .../Sidekick_th_data/Make/argument-1-A/S/T/Term/index.html | 2 +- .../Sidekick_th_data/Make/argument-1-A/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/index.html | 2 +- dev/sidekick/Sidekick_th_data/Make/argument-1-A/index.html | 2 +- .../module-type-ARG/S/Solver_internal/CC/index.html | 2 +- .../module-type-ARG/S/Solver_internal/Simplify/index.html | 2 +- .../module-type-ARG/S/Solver_internal/index.html | 2 +- .../Sidekick_th_data/module-type-ARG/S/T/Term/index.html | 2 +- dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_th_data/module-type-ARG/S/index.html | 2 +- dev/sidekick/Sidekick_th_data/module-type-ARG/index.html | 2 +- .../module-type-S/A/S/Solver_internal/CC/index.html | 2 +- .../module-type-S/A/S/Solver_internal/Simplify/index.html | 2 +- .../module-type-S/A/S/Solver_internal/index.html | 2 +- .../Sidekick_th_data/module-type-S/A/S/T/Term/index.html | 2 +- dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Ty/index.html | 2 +- dev/sidekick/Sidekick_th_data/module-type-S/A/S/index.html | 2 +- dev/sidekick/Sidekick_th_data/module-type-S/A/index.html | 2 +- 479 files changed, 752 insertions(+), 202 deletions(-) create mode 100644 dev/sidekick-base/Sidekick_base/Form/Funs/index.html create mode 100644 dev/sidekick-base/Sidekick_base/Form/Gensym/index.html create mode 100644 dev/sidekick-base/Sidekick_base/Form/index.html create mode 100644 dev/sidekick-base/Sidekick_base__/Form/Funs/index.html create mode 100644 dev/sidekick-base/Sidekick_base__/Form/Gensym/index.html create mode 100644 dev/sidekick-base/Sidekick_base__/Form/index.html rename dev/{sidekick-bin/Sidekick_smtlib__Form => sidekick-base/Sidekick_base__Form}/.dune-keep (100%) create mode 100644 dev/sidekick-base/Sidekick_base__Form/Funs/index.html create mode 100644 dev/sidekick-base/Sidekick_base__Form/Gensym/index.html create mode 100644 dev/sidekick-base/Sidekick_base__Form/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/.dune-keep create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Atom/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Model/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Pre_proof/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Debug_/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Expl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/N/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Simplify/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/Unknown/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver/module-type-THEORY/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Solver_arg/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/Gensym/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Atom/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Model/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Pre_proof/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Debug_/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Expl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/N/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Simplify/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Unknown/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/module-type-THEORY/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/A/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_bool/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/Cstor/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Atom/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Model/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Pre_proof/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Debug_/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Expl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/N/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Simplify/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Unknown/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/module-type-THEORY/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/A/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_data/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Gensym/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Atom/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Model/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Pre_proof/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Debug_/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Expl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/N/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/P/Quip/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/P/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Simplify/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Fun/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Term/Tbl/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Term/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Ty/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Unknown/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/module-type-THEORY/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/A/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/Th_lra/index.html create mode 100644 dev/sidekick-base/Sidekick_base_solver/index.html delete mode 100644 dev/sidekick-bin/Sidekick_smtlib__/Form/Funs/index.html delete mode 100644 dev/sidekick-bin/Sidekick_smtlib__/Form/Gensym/index.html delete mode 100644 dev/sidekick-bin/Sidekick_smtlib__/Form/index.html delete mode 100644 dev/sidekick-bin/Sidekick_smtlib__Form/Funs/index.html delete mode 100644 dev/sidekick-bin/Sidekick_smtlib__Form/Gensym/index.html delete mode 100644 dev/sidekick-bin/Sidekick_smtlib__Form/index.html diff --git a/dev/sidekick-base/Sidekick_base/Arg/Term/index.html b/dev/sidekick-base/Sidekick_base/Arg/Term/index.html index e92f2344..ff1cc78c 100644 --- a/dev/sidekick-base/Sidekick_base/Arg/Term/index.html +++ b/dev/sidekick-base/Sidekick_base/Arg/Term/index.html @@ -1,5 +1,5 @@ -Term (sidekick-base.Sidekick_base.Arg.Term)

Module Arg.Term

Term structure.

Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.

type t = Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state = Term.state

A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.

val ty : t -> Ty.t
val bool : state -> bool -> t

build true/false

val as_bool : t -> bool option

as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.

val abs : state -> t -> t * bool

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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).

The state is passed in case a new term needs to be created.

val map_shallow : state -> (t -> t) -> t -> t

Map function on immediate subterms. This should not be recursive.

val iter_dag : t -> (t -> unit) -> 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.Arg.Term)
Module Arg.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t = Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Term.store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick-base/Sidekick_base/Arg/Ty/index.html b/dev/sidekick-base/Sidekick_base/Arg/Ty/index.html
index 2bda895c..85b442cb 100644
--- a/dev/sidekick-base/Sidekick_base/Arg/Ty/index.html
+++ b/dev/sidekick-base/Sidekick_base/Arg/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick-base.Sidekick_base.Arg.Ty)
Module Arg.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t = Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick-base.Sidekick_base.Arg.Ty)
Module Arg.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t = Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base/Arg/index.html b/dev/sidekick-base/Sidekick_base/Arg/index.html
index 8ab40017..4b8bb616 100644
--- a/dev/sidekick-base/Sidekick_base/Arg/index.html
+++ b/dev/sidekick-base/Sidekick_base/Arg/index.html
@@ -1,2 +1,2 @@
 
-Arg (sidekick-base.Sidekick_base.Arg)
Module Sidekick_base.Arg
module Fun : sig ... end with type t = Fun.t
A function symbol, like "f" or "plus" or "is_human" or "socrates"
module Ty : sig ... end with type t = Ty.t
Types
module Term : sig ... end with type t = Term.t and type state = Term.state
Term structure.

\ No newline at end of file
+Arg (sidekick-base.Sidekick_base.Arg)
Module Sidekick_base.Arg
Concrete implementation of Sidekick_core.TERM
this module gathers most definitions above in a form that is compatible with what Sidekick expects for terms, functions, etc.
module Fun : sig ... end with type t = Fun.t
A function symbol, like "f" or "plus" or "is_human" or "socrates"
module Ty : sig ... end with type t = Ty.t
Types
module Term : sig ... end with type t = Term.t and type store = Term.store
Term structure.

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base/Base_types/Term/index.html b/dev/sidekick-base/Sidekick_base/Base_types/Term/index.html
index e51e4d62..9a195a9d 100644
--- a/dev/sidekick-base/Sidekick_base/Base_types/Term/index.html
+++ b/dev/sidekick-base/Sidekick_base/Base_types/Term/index.html
@@ -1,2 +1,2 @@
 
-Term (sidekick-base.Sidekick_base.Base_types.Term)
Module Base_types.Term
Term creation and manipulation
type t = term = {
mutable term_id : int;
mutable term_ty : ty;
term_view : t term_view;
}
type 'a view = 'a term_view = 
| Bool of bool
| App_fun of fun_ * 'a Sidekick_util.IArray.t
| Eq of 'a * 'a
| Not of 'a
| Ite of 'a * 'a * 'a
| LRA of (Q.t, 'a) lra_view
val id : t -> int
val view : t -> term view
val ty : t -> Ty.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
type state
val create : ?⁠size:int -> unit -> state
val make : state -> t view -> t
val true_ : state -> t
val false_ : state -> t
val bool : state -> bool -> t
val const : state -> fun_ -> t
val app_fun : state -> fun_ -> t Sidekick_util.IArray.t -> t
val eq : state -> t -> t -> t
val not_ : state -> t -> t
val ite : state -> t -> t -> t -> t
val select : state -> select -> t -> t
val app_cstor : state -> cstor -> t Sidekick_util.IArray.t -> t
val is_a : state -> cstor -> t -> t
val lra : state -> (Q.t, t) lra_view -> t
val abs : state -> t -> t * bool
Obtain unsigned version of t, + the sign as a boolean
module Iter_dag : sig ... end
val iter_dag_with : order:Iter_dag.order -> t -> t Iter.t
val iter_dag : t -> t Iter.t
val map_shallow : state -> (t -> t) -> t -> t
val pp : t Fmt.printer
Views
val is_true : t -> bool
val is_false : t -> bool
val is_const : t -> bool
val cc_view : t -> (fun_, t, t Iter.t) CC_view.t
val as_fun_undef : t -> (fun_ * Ty.Fun.t) option
val as_bool : t -> bool option
Containers
module Tbl : CCHashtbl.S with type Tbl.key = t
module Map : CCMap.S with type Map.key = t
module Set : CCSet.S with type Set.elt = t

\ No newline at end of file
+Term (sidekick-base.Sidekick_base.Base_types.Term)
Module Base_types.Term
Term creation and manipulation
type t = term = {
mutable term_id : int;
mutable term_ty : ty;
term_view : t term_view;
}
type 'a view = 'a term_view = 
| Bool of bool
| App_fun of fun_ * 'a Sidekick_util.IArray.t
| Eq of 'a * 'a
| Not of 'a
| Ite of 'a * 'a * 'a
| LRA of (Q.t, 'a) lra_view
val id : t -> int
val view : t -> term view
val ty : t -> Ty.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
type store
val create : ?⁠size:int -> unit -> store
val make : store -> t view -> t
val true_ : store -> t
val false_ : store -> t
val bool : store -> bool -> t
val const : store -> fun_ -> t
val app_fun : store -> fun_ -> t Sidekick_util.IArray.t -> t
val eq : store -> t -> t -> t
val not_ : store -> t -> t
val ite : store -> t -> t -> t -> t
val select : store -> select -> t -> t
val app_cstor : store -> cstor -> t Sidekick_util.IArray.t -> t
val is_a : store -> cstor -> t -> t
val lra : store -> (Q.t, t) lra_view -> t
val abs : store -> t -> t * bool
Obtain unsigned version of t, + the sign as a boolean
module Iter_dag : sig ... end
val iter_dag_with : order:Iter_dag.order -> t -> t Iter.t
val iter_dag : t -> t Iter.t
val map_shallow : store -> (t -> t) -> t -> t
val pp : t Fmt.printer
Views
val is_true : t -> bool
val is_false : t -> bool
val is_const : t -> bool
val cc_view : t -> (fun_, t, t Iter.t) CC_view.t
val as_fun_undef : t -> (fun_ * Ty.Fun.t) option
val as_bool : t -> bool option
Containers
module Tbl : CCHashtbl.S with type Tbl.key = t
module Map : CCMap.S with type Map.key = t
module Set : CCSet.S with type Set.elt = t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base/Base_types/Ty/index.html b/dev/sidekick-base/Sidekick_base/Base_types/Ty/index.html
index 67795050..6262d1cb 100644
--- a/dev/sidekick-base/Sidekick_base/Base_types/Ty/index.html
+++ b/dev/sidekick-base/Sidekick_base/Base_types/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick-base.Sidekick_base.Base_types.Ty)
Module Base_types.Ty
Types
type t = ty
type state = unit
type view = ty_view = 
| Ty_bool
| Ty_real
| Ty_atomic of {
def : ty_def;
args : ty list;
mutable finite : bool;
}
type def = ty_def = 
| Ty_uninterpreted of ID.t
| Ty_data of {
data : data;
}
| Ty_def of {
id : ID.t;
pp : ty Fmt.printer -> ty list Fmt.printer;
default_val : value list -> value;
}
val id : t -> int
val view : t -> view
val bool : state -> t
val real : state -> t
val atomic : def -> t list -> t
val id_of_def : def -> ID.t
val atomic_uninterpreted : ID.t -> t
val finite : t -> bool
val set_finite : t -> bool -> unit
val is_bool : t -> bool
val is_uninterpreted : t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
module Tbl : CCHashtbl.S with type Tbl.key = t
module Fun : sig ... end

\ No newline at end of file
+Ty (sidekick-base.Sidekick_base.Base_types.Ty)
Module Base_types.Ty
Types
type t = ty
type store = unit
type view = ty_view = 
| Ty_bool
| Ty_real
| Ty_atomic of {
def : ty_def;
args : ty list;
mutable finite : bool;
}
type def = ty_def = 
| Ty_uninterpreted of ID.t
| Ty_data of {
data : data;
}
| Ty_def of {
id : ID.t;
pp : ty Fmt.printer -> ty list Fmt.printer;
default_val : value list -> value;
}
val id : t -> int
val view : t -> view
val bool : store -> t
val real : store -> t
val atomic : def -> t list -> t
val id_of_def : def -> ID.t
val atomic_uninterpreted : ID.t -> t
val finite : t -> bool
val set_finite : t -> bool -> unit
val is_bool : t -> bool
val is_uninterpreted : t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
module Tbl : CCHashtbl.S with type Tbl.key = t
module Fun : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base/Form/Funs/index.html b/dev/sidekick-base/Sidekick_base/Form/Funs/index.html
new file mode 100644
index 00000000..e85c6835
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base/Form/Funs/index.html
@@ -0,0 +1,2 @@
+
+Funs (sidekick-base.Sidekick_base.Form.Funs)
Module Form.Funs
val get_ty : 'a -> 'b -> Ty.t
val abs : self:T.t -> 'a -> T.t * bool
val relevant : 'a -> 'b -> 'c -> bool
val eval : ID.t -> Value.t Sidekick_util.IArray.t -> Value.t
val mk_fun : ?⁠do_cc:bool -> ID.t -> Fun.t
val and_ : Fun.t
val or_ : Fun.t
val imply : Fun.t
val ite : T.store -> T.t -> T.t -> T.t -> T.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base/Form/Gensym/index.html b/dev/sidekick-base/Sidekick_base/Form/Gensym/index.html
new file mode 100644
index 00000000..32a3f7d1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base/Form/Gensym/index.html
@@ -0,0 +1,2 @@
+
+Gensym (sidekick-base.Sidekick_base.Form.Gensym)
Module Form.Gensym
type t = {
tst : T.store;
mutable fresh : int;
}
val create : T.store -> t
val fresh_term : t -> pre:string -> Ty.t -> T.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base/Form/index.html b/dev/sidekick-base/Sidekick_base/Form/index.html
new file mode 100644
index 00000000..2a24311d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base/Form/index.html
@@ -0,0 +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.
module T = Base_types.Term
module Ty = Base_types.Ty
module Fun = Base_types.Fun
module Value = Base_types.Value
exception Not_a_th_term
val id_and : ID.t
val id_or : ID.t
val id_imply : ID.t
val view_id : ID.t -> 'a Sidekick_util.IArray.t -> ('a, 'a Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
val view_as_bool : T.t -> (T.t, T.t Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
module Funs : sig ... end
val as_id : ID.t -> T.t -> T.t Sidekick_util.IArray.t option
val flatten_id : ID.t -> bool -> T.t list -> T.t list
val and_l : T.store -> T.t list -> T.t
val or_l : T.store -> T.t list -> T.t
val and_ : T.store -> T.t -> T.t -> T.t
val or_ : T.store -> T.t -> T.t -> T.t
val and_a : T.store -> T.t Sidekick_util.IArray.t -> T.t
val or_a : T.store -> T.t Sidekick_util.IArray.t -> T.t
val eq : T.store -> T.t -> T.t -> T.t
val not_ : T.store -> T.t -> T.t
val ite : T.store -> T.t -> T.t -> T.t -> T.t
val equiv : T.store -> T.t -> T.t -> T.t
val neq : T.store -> T.t -> T.t -> T.t
val imply_a : T.store -> T.t Sidekick_util.IArray.t -> T.t -> T.t
val imply_l : T.store -> T.t list -> T.t -> T.t
val imply : T.store -> T.t -> T.t -> T.t
val xor : T.store -> T.t -> T.t -> T.t
val distinct_l : T.store -> T.t CCList.t -> T.t
val mk_bool : T.store -> (T.t, T.t Sidekick_util.IArray.t) Sidekick_th_bool_static.bool_view -> T.t
module Gensym : sig ... end
val check_congruence_classes : bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base/index.html b/dev/sidekick-base/Sidekick_base/index.html
index b4036a0d..baf37ea8 100644
--- a/dev/sidekick-base/Sidekick_base/index.html
+++ b/dev/sidekick-base/Sidekick_base/index.html
@@ -1,2 +1,2 @@
 
-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 Base_types : sig ... end
Basic type definitions for Sidekick_base
module ID : sig ... end
Unique Identifiers
module Fun = Base_types.Fun
module Stat = Sidekick_util.Stat
module Model : sig ... end
Models
module Term = Base_types.Term
module Value = Base_types.Value
module Term_cell = Base_types.Term_cell
module Ty = Base_types.Ty
module Statement = Base_types.Statement
module Data = Base_types.Data
module Select = Base_types.Select
module Proof : sig ... end
Proofs of unsatisfiability
module Arg : Sidekick_core.TERM with type Term.t = Term.t and type Fun.t = Fun.t and type Ty.t = Ty.t and type Term.state = Term.state

\ No newline at end of file
+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 Base_types : sig ... end
Basic type definitions for Sidekick_base
module ID : sig ... end
Unique Identifiers
module Fun = Base_types.Fun
module Stat = Sidekick_util.Stat
module Model : sig ... end
Models
module Term = Base_types.Term
module Value = Base_types.Value
module Term_cell = Base_types.Term_cell
module Ty = Base_types.Ty
module Statement = Base_types.Statement
module Data = Base_types.Data
module Select = Base_types.Select
module Proof : sig ... end
Proofs of unsatisfiability
module Form : sig ... end
Formulas (boolean terms).
module Arg : Sidekick_core.TERM with type Term.t = Term.t and type Fun.t = Fun.t and type Ty.t = Ty.t and type Term.store = Term.store
Concrete implementation of Sidekick_core.TERM

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__/Base_types/Term/index.html b/dev/sidekick-base/Sidekick_base__/Base_types/Term/index.html
index b72c390e..6dd1ea03 100644
--- a/dev/sidekick-base/Sidekick_base__/Base_types/Term/index.html
+++ b/dev/sidekick-base/Sidekick_base__/Base_types/Term/index.html
@@ -1,2 +1,2 @@
 
-Term (sidekick-base.Sidekick_base__.Base_types.Term)
Module Base_types.Term
Term creation and manipulation
type t = term = {
mutable term_id : int;
mutable term_ty : ty;
term_view : t term_view;
}
type 'a view = 'a term_view = 
| Bool of bool
| App_fun of fun_ * 'a Sidekick_util.IArray.t
| Eq of 'a * 'a
| Not of 'a
| Ite of 'a * 'a * 'a
| LRA of (Q.t, 'a) lra_view
val id : t -> int
val view : t -> term view
val ty : t -> Ty.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
type state
val create : ?⁠size:int -> unit -> state
val make : state -> t view -> t
val true_ : state -> t
val false_ : state -> t
val bool : state -> bool -> t
val const : state -> fun_ -> t
val app_fun : state -> fun_ -> t Sidekick_util.IArray.t -> t
val eq : state -> t -> t -> t
val not_ : state -> t -> t
val ite : state -> t -> t -> t -> t
val select : state -> select -> t -> t
val app_cstor : state -> cstor -> t Sidekick_util.IArray.t -> t
val is_a : state -> cstor -> t -> t
val lra : state -> (Q.t, t) lra_view -> t
val abs : state -> t -> t * bool
Obtain unsigned version of t, + the sign as a boolean
module Iter_dag : sig ... end
val iter_dag_with : order:Iter_dag.order -> t -> t Iter.t
val iter_dag : t -> t Iter.t
val map_shallow : state -> (t -> t) -> t -> t
val pp : t Fmt.printer
Views
val is_true : t -> bool
val is_false : t -> bool
val is_const : t -> bool
val cc_view : t -> (fun_, t, t Iter.t) CC_view.t
val as_fun_undef : t -> (fun_ * Ty.Fun.t) option
val as_bool : t -> bool option
Containers
module Tbl : CCHashtbl.S with type Tbl.key = t
module Map : CCMap.S with type Map.key = t
module Set : CCSet.S with type Set.elt = t

\ No newline at end of file
+Term (sidekick-base.Sidekick_base__.Base_types.Term)
Module Base_types.Term
Term creation and manipulation
type t = term = {
mutable term_id : int;
mutable term_ty : ty;
term_view : t term_view;
}
type 'a view = 'a term_view = 
| Bool of bool
| App_fun of fun_ * 'a Sidekick_util.IArray.t
| Eq of 'a * 'a
| Not of 'a
| Ite of 'a * 'a * 'a
| LRA of (Q.t, 'a) lra_view
val id : t -> int
val view : t -> term view
val ty : t -> Ty.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
type store
val create : ?⁠size:int -> unit -> store
val make : store -> t view -> t
val true_ : store -> t
val false_ : store -> t
val bool : store -> bool -> t
val const : store -> fun_ -> t
val app_fun : store -> fun_ -> t Sidekick_util.IArray.t -> t
val eq : store -> t -> t -> t
val not_ : store -> t -> t
val ite : store -> t -> t -> t -> t
val select : store -> select -> t -> t
val app_cstor : store -> cstor -> t Sidekick_util.IArray.t -> t
val is_a : store -> cstor -> t -> t
val lra : store -> (Q.t, t) lra_view -> t
val abs : store -> t -> t * bool
Obtain unsigned version of t, + the sign as a boolean
module Iter_dag : sig ... end
val iter_dag_with : order:Iter_dag.order -> t -> t Iter.t
val iter_dag : t -> t Iter.t
val map_shallow : store -> (t -> t) -> t -> t
val pp : t Fmt.printer
Views
val is_true : t -> bool
val is_false : t -> bool
val is_const : t -> bool
val cc_view : t -> (fun_, t, t Iter.t) CC_view.t
val as_fun_undef : t -> (fun_ * Ty.Fun.t) option
val as_bool : t -> bool option
Containers
module Tbl : CCHashtbl.S with type Tbl.key = t
module Map : CCMap.S with type Map.key = t
module Set : CCSet.S with type Set.elt = t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__/Base_types/Ty/index.html b/dev/sidekick-base/Sidekick_base__/Base_types/Ty/index.html
index ca529d12..2f2bbd17 100644
--- a/dev/sidekick-base/Sidekick_base__/Base_types/Ty/index.html
+++ b/dev/sidekick-base/Sidekick_base__/Base_types/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick-base.Sidekick_base__.Base_types.Ty)
Module Base_types.Ty
Types
type t = ty
type state = unit
type view = ty_view = 
| Ty_bool
| Ty_real
| Ty_atomic of {
def : ty_def;
args : ty list;
mutable finite : bool;
}
type def = ty_def = 
| Ty_uninterpreted of Sidekick_base.ID.t
| Ty_data of {
data : data;
}
| Ty_def of {
id : Sidekick_base.ID.t;
pp : ty Fmt.printer -> ty list Fmt.printer;
default_val : value list -> value;
}
val id : t -> int
val view : t -> view
val bool : state -> t
val real : state -> t
val atomic : def -> t list -> t
val id_of_def : def -> Sidekick_base.ID.t
val atomic_uninterpreted : Sidekick_base.ID.t -> t
val finite : t -> bool
val set_finite : t -> bool -> unit
val is_bool : t -> bool
val is_uninterpreted : t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
module Tbl : CCHashtbl.S with type Tbl.key = t
module Fun : sig ... end

\ No newline at end of file
+Ty (sidekick-base.Sidekick_base__.Base_types.Ty)
Module Base_types.Ty
Types
type t = ty
type store = unit
type view = ty_view = 
| Ty_bool
| Ty_real
| Ty_atomic of {
def : ty_def;
args : ty list;
mutable finite : bool;
}
type def = ty_def = 
| Ty_uninterpreted of Sidekick_base.ID.t
| Ty_data of {
data : data;
}
| Ty_def of {
id : Sidekick_base.ID.t;
pp : ty Fmt.printer -> ty list Fmt.printer;
default_val : value list -> value;
}
val id : t -> int
val view : t -> view
val bool : store -> t
val real : store -> t
val atomic : def -> t list -> t
val id_of_def : def -> Sidekick_base.ID.t
val atomic_uninterpreted : Sidekick_base.ID.t -> t
val finite : t -> bool
val set_finite : t -> bool -> unit
val is_bool : t -> bool
val is_uninterpreted : t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
module Tbl : CCHashtbl.S with type Tbl.key = t
module Fun : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__/Form/Funs/index.html b/dev/sidekick-base/Sidekick_base__/Form/Funs/index.html
new file mode 100644
index 00000000..cd1fff5e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base__/Form/Funs/index.html
@@ -0,0 +1,2 @@
+
+Funs (sidekick-base.Sidekick_base__.Form.Funs)
Module Form.Funs
val get_ty : 'a -> 'b -> Ty.t
val abs : self:T.t -> 'a -> T.t * bool
val relevant : 'a -> 'b -> 'c -> bool
val eval : Sidekick_base.ID.t -> Value.t Sidekick_util.IArray.t -> Value.t
val mk_fun : ?⁠do_cc:bool -> Sidekick_base.ID.t -> Fun.t
val and_ : Fun.t
val or_ : Fun.t
val imply : Fun.t
val ite : T.store -> T.t -> T.t -> T.t -> T.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__/Form/Gensym/index.html b/dev/sidekick-base/Sidekick_base__/Form/Gensym/index.html
new file mode 100644
index 00000000..cadf12d8
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base__/Form/Gensym/index.html
@@ -0,0 +1,2 @@
+
+Gensym (sidekick-base.Sidekick_base__.Form.Gensym)
Module Form.Gensym
type t = {
tst : T.store;
mutable fresh : int;
}
val create : T.store -> t
val fresh_term : t -> pre:string -> Ty.t -> T.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__/Form/index.html b/dev/sidekick-base/Sidekick_base__/Form/index.html
new file mode 100644
index 00000000..884c9c1a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base__/Form/index.html
@@ -0,0 +1,2 @@
+
+Form (sidekick-base.Sidekick_base__.Form)
Module Sidekick_base__.Form
exception Not_a_th_term
val id_and : Sidekick_base.ID.t
val id_or : Sidekick_base.ID.t
val id_imply : Sidekick_base.ID.t
val view_id : Sidekick_base.ID.t -> 'a Sidekick_util.IArray.t -> ('a, 'a Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
val view_as_bool : T.t -> (T.t, T.t Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
module Funs : sig ... end
val as_id : Sidekick_base.ID.t -> T.t -> T.t Sidekick_util.IArray.t option
val flatten_id : Sidekick_base.ID.t -> bool -> T.t list -> T.t list
val and_l : T.store -> T.t list -> T.t
val or_l : T.store -> T.t list -> T.t
val and_ : T.store -> T.t -> T.t -> T.t
val or_ : T.store -> T.t -> T.t -> T.t
val and_a : T.store -> T.t Sidekick_util.IArray.t -> T.t
val or_a : T.store -> T.t Sidekick_util.IArray.t -> T.t
val eq : T.store -> T.t -> T.t -> T.t
val not_ : T.store -> T.t -> T.t
val ite : T.store -> T.t -> T.t -> T.t -> T.t
val equiv : T.store -> T.t -> T.t -> T.t
val neq : T.store -> T.t -> T.t -> T.t
val imply_a : T.store -> T.t Sidekick_util.IArray.t -> T.t -> T.t
val imply_l : T.store -> T.t list -> T.t -> T.t
val imply : T.store -> T.t -> T.t -> T.t
val xor : T.store -> T.t -> T.t -> T.t
val distinct_l : T.store -> T.t CCList.t -> T.t
val mk_bool : T.store -> (T.t, T.t Sidekick_util.IArray.t) Sidekick_th_bool_static.bool_view -> T.t
module Gensym : sig ... end
val check_congruence_classes : bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__/index.html b/dev/sidekick-base/Sidekick_base__/index.html
index acb8b58e..464e06af 100644
--- a/dev/sidekick-base/Sidekick_base__/index.html
+++ b/dev/sidekick-base/Sidekick_base__/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_base__ (sidekick-base.Sidekick_base__)
Module Sidekick_base__
module Base_types : sig ... end
module CCHet : sig ... end
module Config : sig ... end
module Hashcons : sig ... end
module ID : sig ... end
module Model : sig ... end
module Proof : sig ... end

\ No newline at end of file
+Sidekick_base__ (sidekick-base.Sidekick_base__)
Module Sidekick_base__
module Base_types : sig ... end
module CCHet : sig ... end
module Config : sig ... end
module Form : sig ... end
module Hashcons : sig ... end
module ID : sig ... end
module Model : sig ... end
module Proof : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__Base_types/Term/index.html b/dev/sidekick-base/Sidekick_base__Base_types/Term/index.html
index 05d8be02..559c4790 100644
--- a/dev/sidekick-base/Sidekick_base__Base_types/Term/index.html
+++ b/dev/sidekick-base/Sidekick_base__Base_types/Term/index.html
@@ -1,2 +1,2 @@
 
-Term (sidekick-base.Sidekick_base__Base_types.Term)
Module Sidekick_base__Base_types.Term
Term creation and manipulation
type t = term = {
mutable term_id : int;
mutable term_ty : ty;
term_view : t term_view;
}
type 'a view = 'a term_view = 
| Bool of bool
| App_fun of fun_ * 'a Sidekick_util.IArray.t
| Eq of 'a * 'a
| Not of 'a
| Ite of 'a * 'a * 'a
| LRA of (Q.t, 'a) lra_view
val id : t -> int
val view : t -> term view
val ty : t -> Ty.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
type state
val create : ?⁠size:int -> unit -> state
val make : state -> t view -> t
val true_ : state -> t
val false_ : state -> t
val bool : state -> bool -> t
val const : state -> fun_ -> t
val app_fun : state -> fun_ -> t Sidekick_util.IArray.t -> t
val eq : state -> t -> t -> t
val not_ : state -> t -> t
val ite : state -> t -> t -> t -> t
val select : state -> select -> t -> t
val app_cstor : state -> cstor -> t Sidekick_util.IArray.t -> t
val is_a : state -> cstor -> t -> t
val lra : state -> (Q.t, t) lra_view -> t
val abs : state -> t -> t * bool
Obtain unsigned version of t, + the sign as a boolean
module Iter_dag : sig ... end
val iter_dag_with : order:Iter_dag.order -> t -> t Iter.t
val iter_dag : t -> t Iter.t
val map_shallow : state -> (t -> t) -> t -> t
val pp : t Fmt.printer
Views
val is_true : t -> bool
val is_false : t -> bool
val is_const : t -> bool
val cc_view : t -> (fun_, t, t Iter.t) CC_view.t
val as_fun_undef : t -> (fun_ * Ty.Fun.t) option
val as_bool : t -> bool option
Containers
module Tbl : CCHashtbl.S with type Tbl.key = t
module Map : CCMap.S with type Map.key = t
module Set : CCSet.S with type Set.elt = t

\ No newline at end of file
+Term (sidekick-base.Sidekick_base__Base_types.Term)
Module Sidekick_base__Base_types.Term
Term creation and manipulation
type t = term = {
mutable term_id : int;
mutable term_ty : ty;
term_view : t term_view;
}
type 'a view = 'a term_view = 
| Bool of bool
| App_fun of fun_ * 'a Sidekick_util.IArray.t
| Eq of 'a * 'a
| Not of 'a
| Ite of 'a * 'a * 'a
| LRA of (Q.t, 'a) lra_view
val id : t -> int
val view : t -> term view
val ty : t -> Ty.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
type store
val create : ?⁠size:int -> unit -> store
val make : store -> t view -> t
val true_ : store -> t
val false_ : store -> t
val bool : store -> bool -> t
val const : store -> fun_ -> t
val app_fun : store -> fun_ -> t Sidekick_util.IArray.t -> t
val eq : store -> t -> t -> t
val not_ : store -> t -> t
val ite : store -> t -> t -> t -> t
val select : store -> select -> t -> t
val app_cstor : store -> cstor -> t Sidekick_util.IArray.t -> t
val is_a : store -> cstor -> t -> t
val lra : store -> (Q.t, t) lra_view -> t
val abs : store -> t -> t * bool
Obtain unsigned version of t, + the sign as a boolean
module Iter_dag : sig ... end
val iter_dag_with : order:Iter_dag.order -> t -> t Iter.t
val iter_dag : t -> t Iter.t
val map_shallow : store -> (t -> t) -> t -> t
val pp : t Fmt.printer
Views
val is_true : t -> bool
val is_false : t -> bool
val is_const : t -> bool
val cc_view : t -> (fun_, t, t Iter.t) CC_view.t
val as_fun_undef : t -> (fun_ * Ty.Fun.t) option
val as_bool : t -> bool option
Containers
module Tbl : CCHashtbl.S with type Tbl.key = t
module Map : CCMap.S with type Map.key = t
module Set : CCSet.S with type Set.elt = t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__Base_types/Ty/index.html b/dev/sidekick-base/Sidekick_base__Base_types/Ty/index.html
index 3444603e..63ca9aad 100644
--- a/dev/sidekick-base/Sidekick_base__Base_types/Ty/index.html
+++ b/dev/sidekick-base/Sidekick_base__Base_types/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick-base.Sidekick_base__Base_types.Ty)
Module Sidekick_base__Base_types.Ty
Types
type t = ty
type state = unit
type view = ty_view = 
| Ty_bool
| Ty_real
| Ty_atomic of {
def : ty_def;
args : ty list;
mutable finite : bool;
}
type def = ty_def = 
| Ty_uninterpreted of Sidekick_base.ID.t
| Ty_data of {
data : data;
}
| Ty_def of {
id : Sidekick_base.ID.t;
pp : ty Fmt.printer -> ty list Fmt.printer;
default_val : value list -> value;
}
val id : t -> int
val view : t -> view
val bool : state -> t
val real : state -> t
val atomic : def -> t list -> t
val id_of_def : def -> Sidekick_base.ID.t
val atomic_uninterpreted : Sidekick_base.ID.t -> t
val finite : t -> bool
val set_finite : t -> bool -> unit
val is_bool : t -> bool
val is_uninterpreted : t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
module Tbl : CCHashtbl.S with type Tbl.key = t
module Fun : sig ... end

\ No newline at end of file
+Ty (sidekick-base.Sidekick_base__Base_types.Ty)
Module Sidekick_base__Base_types.Ty
Types
type t = ty
type store = unit
type view = ty_view = 
| Ty_bool
| Ty_real
| Ty_atomic of {
def : ty_def;
args : ty list;
mutable finite : bool;
}
type def = ty_def = 
| Ty_uninterpreted of Sidekick_base.ID.t
| Ty_data of {
data : data;
}
| Ty_def of {
id : Sidekick_base.ID.t;
pp : ty Fmt.printer -> ty list Fmt.printer;
default_val : value list -> value;
}
val id : t -> int
val view : t -> view
val bool : store -> t
val real : store -> t
val atomic : def -> t list -> t
val id_of_def : def -> Sidekick_base.ID.t
val atomic_uninterpreted : Sidekick_base.ID.t -> t
val finite : t -> bool
val set_finite : t -> bool -> unit
val is_bool : t -> bool
val is_uninterpreted : t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
module Tbl : CCHashtbl.S with type Tbl.key = t
module Fun : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Form/.dune-keep b/dev/sidekick-base/Sidekick_base__Form/.dune-keep
similarity index 100%
rename from dev/sidekick-bin/Sidekick_smtlib__Form/.dune-keep
rename to dev/sidekick-base/Sidekick_base__Form/.dune-keep
diff --git a/dev/sidekick-base/Sidekick_base__Form/Funs/index.html b/dev/sidekick-base/Sidekick_base__Form/Funs/index.html
new file mode 100644
index 00000000..aba5b8d2
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base__Form/Funs/index.html
@@ -0,0 +1,2 @@
+
+Funs (sidekick-base.Sidekick_base__Form.Funs)
Module Sidekick_base__Form.Funs
val get_ty : 'a -> 'b -> Ty.t
val abs : self:T.t -> 'a -> T.t * bool
val relevant : 'a -> 'b -> 'c -> bool
val eval : Sidekick_base.ID.t -> Value.t Sidekick_util.IArray.t -> Value.t
val mk_fun : ?⁠do_cc:bool -> Sidekick_base.ID.t -> Fun.t
val and_ : Fun.t
val or_ : Fun.t
val imply : Fun.t
val ite : T.store -> T.t -> T.t -> T.t -> T.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__Form/Gensym/index.html b/dev/sidekick-base/Sidekick_base__Form/Gensym/index.html
new file mode 100644
index 00000000..5cf2a901
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base__Form/Gensym/index.html
@@ -0,0 +1,2 @@
+
+Gensym (sidekick-base.Sidekick_base__Form.Gensym)
Module Sidekick_base__Form.Gensym
type t = {
tst : T.store;
mutable fresh : int;
}
val create : T.store -> t
val fresh_term : t -> pre:string -> Ty.t -> T.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base__Form/index.html b/dev/sidekick-base/Sidekick_base__Form/index.html
new file mode 100644
index 00000000..c86e6ec3
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base__Form/index.html
@@ -0,0 +1,2 @@
+
+Sidekick_base__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.
exception Not_a_th_term
val id_and : Sidekick_base.ID.t
val id_or : Sidekick_base.ID.t
val id_imply : Sidekick_base.ID.t
val view_id : Sidekick_base.ID.t -> 'a Sidekick_util.IArray.t -> ('a, 'a Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
val view_as_bool : T.t -> (T.t, T.t Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
module Funs : sig ... end
val as_id : Sidekick_base.ID.t -> T.t -> T.t Sidekick_util.IArray.t option
val flatten_id : Sidekick_base.ID.t -> bool -> T.t list -> T.t list
val and_l : T.store -> T.t list -> T.t
val or_l : T.store -> T.t list -> T.t
val and_ : T.store -> T.t -> T.t -> T.t
val or_ : T.store -> T.t -> T.t -> T.t
val and_a : T.store -> T.t Sidekick_util.IArray.t -> T.t
val or_a : T.store -> T.t Sidekick_util.IArray.t -> T.t
val eq : T.store -> T.t -> T.t -> T.t
val not_ : T.store -> T.t -> T.t
val ite : T.store -> T.t -> T.t -> T.t -> T.t
val equiv : T.store -> T.t -> T.t -> T.t
val neq : T.store -> T.t -> T.t -> T.t
val imply_a : T.store -> T.t Sidekick_util.IArray.t -> T.t -> T.t
val imply_l : T.store -> T.t list -> T.t -> T.t
val imply : T.store -> T.t -> T.t -> T.t
val xor : T.store -> T.t -> T.t -> T.t
val distinct_l : T.store -> T.t CCList.t -> T.t
val mk_bool : T.store -> (T.t, T.t Sidekick_util.IArray.t) Sidekick_th_bool_static.bool_view -> T.t
module Gensym : sig ... end
val check_congruence_classes : bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/.dune-keep b/dev/sidekick-base/Sidekick_base_solver/.dune-keep
new file mode 100644
index 00000000..e69de29b
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Atom/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Atom/index.html
new file mode 100644
index 00000000..61aa8899
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Atom/index.html
@@ -0,0 +1,2 @@
+
+Atom (sidekick-base.Sidekick_base_solver.Solver.Atom)
Module Solver.Atom
type t = Sidekick_msat_solver.Make(Solver_arg).Atom.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t CCFormat.printer
val neg : t -> t
val formula : t -> lit
val sign : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Fun/index.html
new file mode 100644
index 00000000..7c76ed10
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Solver.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..b807ed60
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Solver.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Term/index.html
new file mode 100644
index 00000000..b658be26
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Solver.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Ty/index.html
new file mode 100644
index 00000000..7c90c8d2
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Solver.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/index.html
new file mode 100644
index 00000000..eb28d15a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Solver.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/index.html
new file mode 100644
index 00000000..02ea3806
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Solver.Lit)
Module Solver.Lit
module T : sig ... end
type t = Sidekick_msat_solver.Make(Solver_arg).Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Model/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Model/index.html
new file mode 100644
index 00000000..acbff186
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Model/index.html
@@ -0,0 +1,2 @@
+
+Model (sidekick-base.Sidekick_base_solver.Solver.Model)
Module Solver.Model
type t = Sidekick_msat_solver.Make(Solver_arg).Model.t
val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/P/Quip/index.html
new file mode 100644
index 00000000..d87eae0f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Solver.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/P/index.html
new file mode 100644
index 00000000..c1759db5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Solver.P)
Module Solver.P
type t = Solver_arg.P.t
type term = Solver_arg.T.Term.t
type ty = Solver_arg.P.ty
type hres_step = Solver_arg.P.hres_step
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
type lit = Solver_arg.P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = Solver_arg.P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Pre_proof/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Pre_proof/index.html
new file mode 100644
index 00000000..2bf4afed
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Pre_proof/index.html
@@ -0,0 +1,2 @@
+
+Pre_proof (sidekick-base.Sidekick_base_solver.Solver.Pre_proof)
Module Solver.Pre_proof
type t = Sidekick_msat_solver.Make(Solver_arg).Pre_proof.t
val output : Stdlib.out_channel -> t -> unit
val pp_debug : t Sidekick_core.Fmt.printer
val pp_dot : t Sidekick_core.Fmt.printer option
val check : t -> unit
val to_proof : t -> P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Fun/index.html
new file mode 100644
index 00000000..17581444
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..f4ba61f2
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Term/index.html
new file mode 100644
index 00000000..cfeaf6fe
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Ty/index.html
new file mode 100644
index 00000000..77178b82
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/index.html
new file mode 100644
index 00000000..9d7bad3a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/index.html
new file mode 100644
index 00000000..8c323f1b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.Lit)
Module Actions.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/P/Quip/index.html
new file mode 100644
index 00000000..964f5f79
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/P/index.html
new file mode 100644
index 00000000..f790da77
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.P)
Module Actions.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Fun/index.html
new file mode 100644
index 00000000..df613d63
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Term/Tbl/index.html
new file mode 100644
index 00000000..743b2db5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Term/index.html
new file mode 100644
index 00000000..cc572c8b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Ty/index.html
new file mode 100644
index 00000000..cbb6e6ef
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/index.html
new file mode 100644
index 00000000..4837f4ec
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.T)
Module Actions.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/index.html
new file mode 100644
index 00000000..c469c1b2
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/index.html
@@ -0,0 +1,2 @@
+
+Actions (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions)
Module CC.Actions
module T : sig ... end
module Lit : sig ... end
module P : sig ... end
type t = actions
val raise_conflict : t -> Lit.t list -> P.t -> 'a
val propagate : t -> Lit.t -> reason:(unit -> Lit.t list * P.t) -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Debug_/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Debug_/index.html
new file mode 100644
index 00000000..b121664a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Debug_/index.html
@@ -0,0 +1,2 @@
+
+Debug_ (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Debug_)
Module CC.Debug_
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Expl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Expl/index.html
new file mode 100644
index 00000000..8fe2e4ad
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Expl/index.html
@@ -0,0 +1,2 @@
+
+Expl (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Expl)
Module CC.Expl
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.Expl.t
val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t
val mk_merge_t : term -> term -> t
val mk_lit : lit -> t
val mk_list : t list -> t
val mk_proof : P.t -> t
val mk_theory : t -> t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Fun/index.html
new file mode 100644
index 00000000..2efc0b16
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..81708e43
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Term/index.html
new file mode 100644
index 00000000..5f7f3dbd
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Ty/index.html
new file mode 100644
index 00000000..4c7d2337
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/index.html
new file mode 100644
index 00000000..6ef1a19a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/index.html
new file mode 100644
index 00000000..929470be
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Lit)
Module CC.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/N/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/N/index.html
new file mode 100644
index 00000000..751a5430
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/N/index.html
@@ -0,0 +1,2 @@
+
+N (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.N)
Module CC.N
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.N.t
val term : t -> term
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
val is_root : t -> bool
val iter_class : t -> t Iter.t
val iter_parents : t -> t Iter.t
type bitfield = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.N.bitfield
val get_field : bitfield -> t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/P/Quip/index.html
new file mode 100644
index 00000000..87e39882
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/P/index.html
new file mode 100644
index 00000000..e435cb98
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.P)
Module CC.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Fun/index.html
new file mode 100644
index 00000000..33d6a4e0
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Term/Tbl/index.html
new file mode 100644
index 00000000..b4acbf16
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Term/index.html
new file mode 100644
index 00000000..950b734b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Ty/index.html
new file mode 100644
index 00000000..745309e1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/index.html
new file mode 100644
index 00000000..887473e1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.T)
Module CC.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/index.html
new file mode 100644
index 00000000..3591c947
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/index.html
@@ -0,0 +1,2 @@
+
+CC (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC)
Module Solver_internal.CC
module T : sig ... end
module P : sig ... end
module Lit : sig ... end
module Actions : sig ... end
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.t
module N : sig ... end
module Expl : sig ... end
type node = N.t
type repr = N.t
type explanation = Expl.t
val term_store : t -> term_store
val find : t -> node -> repr
val add_term : t -> term -> node
val mem_term : t -> term -> bool
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
type ev_on_new_term = t -> N.t -> term -> unit
type ev_on_conflict = t -> th:bool -> lit list -> unit
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
type ev_on_is_subterm = N.t -> term -> unit
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Big | `Small ] -> term_store -> t
val allocate_bitfield : descr:string -> t -> N.bitfield
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
val on_pre_merge : t -> ev_on_pre_merge -> unit
val on_post_merge : t -> ev_on_post_merge -> unit
val on_new_term : t -> ev_on_new_term -> unit
val on_conflict : t -> ev_on_conflict -> unit
val on_propagate : t -> ev_on_propagate -> unit
val on_is_subterm : t -> ev_on_is_subterm -> unit
val set_as_lit : t -> N.t -> lit -> unit
val find_t : t -> term -> repr
val add_seq : t -> term Iter.t -> unit
val all_classes : t -> repr Iter.t
val assert_lit : t -> lit -> unit
val assert_lits : t -> lit Iter.t -> unit
val explain_eq : t -> N.t -> N.t -> lit list
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
val n_true : t -> N.t
val n_false : t -> N.t
val n_bool : t -> bool -> N.t
val merge : t -> N.t -> N.t -> Expl.t -> unit
val merge_t : t -> term -> term -> Expl.t -> unit
val check : t -> actions -> unit
val new_merges : t -> bool
val push_level : t -> unit
val pop_levels : t -> int -> unit
val get_model : t -> N.t Iter.t Iter.t
module Debug_ : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Fun/index.html
new file mode 100644
index 00000000..f400ade3
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..4b49da31
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Term/index.html
new file mode 100644
index 00000000..fe5e8a04
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Ty/index.html
new file mode 100644
index 00000000..8ff1680d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/index.html
new file mode 100644
index 00000000..3f060e6b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/index.html
new file mode 100644
index 00000000..d03c22f5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Lit)
Module Solver_internal.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/P/Quip/index.html
new file mode 100644
index 00000000..b5db28f1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/P/index.html
new file mode 100644
index 00000000..a58932e5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.P)
Module Solver_internal.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Simplify/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Simplify/index.html
new file mode 100644
index 00000000..1b4d1c58
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Simplify/index.html
@@ -0,0 +1,2 @@
+
+Simplify (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Simplify)
Module Solver_internal.Simplify
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.Simplify.t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
type hook = t -> term -> (term * proof) option
val normalize : t -> term -> (term * P.t) option
val normalize_t : t -> term -> term * P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Fun/index.html
new file mode 100644
index 00000000..6640c5f6
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Term/Tbl/index.html
new file mode 100644
index 00000000..68fb3dde
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Term/index.html
new file mode 100644
index 00000000..19d49d3e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Ty/index.html
new file mode 100644
index 00000000..21c73890
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/index.html
new file mode 100644
index 00000000..05a0a973
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.T)
Module Solver_internal.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/index.html
new file mode 100644
index 00000000..6c5c3b62
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/index.html
@@ -0,0 +1,2 @@
+
+Solver_internal (sidekick-base.Sidekick_base_solver.Solver.Solver_internal)
Module Solver.Solver_internal
module T : sig ... end
module P : sig ... end
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.t
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
type actions = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.actions
module Lit : sig ... end
type lit = Lit.t
val define_const : t -> const:term -> rhs:term -> unit
module CC : sig ... end
val cc : t -> CC.t
module Simplify : sig ... end
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
val simp_t : t -> term -> term * proof
val raise_conflict : t -> actions -> lit list -> proof -> 'a
val push_decision : t -> actions -> lit -> unit
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
val add_clause_temp : t -> actions -> lit list -> proof -> unit
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
val add_lit : t -> actions -> lit -> unit
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
val cc_find : t -> CC.N.t -> CC.N.t
val cc_are_equal : t -> term -> term -> bool
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
val cc_add_term : t -> term -> CC.N.t
val cc_mem_term : t -> term -> bool
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
val on_preprocess : t -> preprocess_hook -> unit
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
val on_model_gen : t -> model_hook -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/T/Fun/index.html
new file mode 100644
index 00000000..466fe34c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Solver.T.Fun)
Module T.Fun
type t = Solver_arg.T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/Tbl/index.html
new file mode 100644
index 00000000..e8646c8e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Solver.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a Solver_arg.T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/index.html
new file mode 100644
index 00000000..0071797b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Solver.T.Term)
Module T.Term
type t = Solver_arg.T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Solver_arg.T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/T/Ty/index.html
new file mode 100644
index 00000000..9595c8f7
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Solver.T.Ty)
Module T.Ty
type t = Solver_arg.T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Solver_arg.T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/T/index.html
new file mode 100644
index 00000000..999aada0
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Solver.T)
Module Solver.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/Unknown/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/Unknown/index.html
new file mode 100644
index 00000000..ef72a195
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/Unknown/index.html
@@ -0,0 +1,2 @@
+
+Unknown (sidekick-base.Sidekick_base_solver.Solver.Unknown)
Module Solver.Unknown
type t = Sidekick_msat_solver.Make(Solver_arg).Unknown.t
val pp : t CCFormat.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/index.html
new file mode 100644
index 00000000..e92e8838
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/index.html
@@ -0,0 +1,2 @@
+
+Solver (sidekick-base.Sidekick_base_solver.Solver)
Module Sidekick_base_solver.Solver
SMT solver, obtained from Sidekick_msat_solver
module T : sig ... end
module P : sig ... end
module Lit : sig ... end
module Solver_internal : sig ... end
type t = Sidekick_msat_solver.Make(Solver_arg).t
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
type !'a theory_p = (module THEORY with type t = 'a)
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
module Atom : sig ... end
module Model : sig ... end
module Unknown : sig ... end
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Small | `Tiny ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.store -> unit -> t
val add_theory : t -> theory -> unit
val add_theory_p : t -> 'a theory_p -> 'a
val add_theory_l : t -> theory list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> unit
val add_clause_l : t -> Atom.t list -> P.t -> unit
module Pre_proof : sig ... end
type res = Sidekick_msat_solver.Make(Solver_arg).res = 
| Sat of Model.t
| Unsat of {
proof : Pre_proof.t option lazy_t;
unsat_core : Atom.t list lazy_t;
}
| Unknown of Unknown.t
val solve : ?⁠on_exit:(unit -> unit) list -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
val pp_stats : t CCFormat.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver/module-type-THEORY/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver/module-type-THEORY/index.html
new file mode 100644
index 00000000..3714d6d1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver/module-type-THEORY/index.html
@@ -0,0 +1,2 @@
+
+THEORY (sidekick-base.Sidekick_base_solver.Solver.THEORY)
Module type Solver.THEORY
type t
val name : string
val create_and_setup : Solver_internal.t -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Solver_arg/index.html b/dev/sidekick-base/Sidekick_base_solver/Solver_arg/index.html
new file mode 100644
index 00000000..c2424c1f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Solver_arg/index.html
@@ -0,0 +1,2 @@
+
+Solver_arg (sidekick-base.Sidekick_base_solver.Solver_arg)
Module Sidekick_base_solver.Solver_arg
Argument to the SMT solver
module T = Sidekick_base
val cc_view : Sidekick_base.Term.t -> (Sidekick_base__Base_types.fun_, Sidekick_base.Term.t, Sidekick_base.Term.t Iter.t) Sidekick_base__Base_types.CC_view.t
val is_valid_literal : 'a -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/Gensym/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/Gensym/index.html
new file mode 100644
index 00000000..71b45e52
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/Gensym/index.html
@@ -0,0 +1,2 @@
+
+Gensym (sidekick-base.Sidekick_base_solver.Th_bool.A.Gensym)
Module A.Gensym
type t = Sidekick_base__Form.Gensym.t
val create : S.T.Term.store -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Atom/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Atom/index.html
new file mode 100644
index 00000000..4a1b2535
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Atom/index.html
@@ -0,0 +1,2 @@
+
+Atom (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Atom)
Module S.Atom
type t = Sidekick_msat_solver.Make(Solver_arg).Atom.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t CCFormat.printer
val neg : t -> t
val formula : t -> lit
val sign : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Fun/index.html
new file mode 100644
index 00000000..72cd4717
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..39e34ca1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/index.html
new file mode 100644
index 00000000..24ff7466
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Ty/index.html
new file mode 100644
index 00000000..fc2d97e3
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/index.html
new file mode 100644
index 00000000..31898339
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/index.html
new file mode 100644
index 00000000..bb4d93b3
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Lit)
Module S.Lit
module T : sig ... end
type t = Sidekick_msat_solver.Make(Solver_arg).Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Model/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Model/index.html
new file mode 100644
index 00000000..ea1045cc
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Model/index.html
@@ -0,0 +1,2 @@
+
+Model (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Model)
Module S.Model
type t = Sidekick_msat_solver.Make(Solver_arg).Model.t
val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/Quip/index.html
new file mode 100644
index 00000000..1e01f0ee
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_bool.A.S.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/index.html
new file mode 100644
index 00000000..ab13d1f6
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_bool.A.S.P)
Module S.P
type t = Solver_arg.P.t
type term = T.Term.t
type ty = Solver_arg.P.ty
type hres_step = Solver_arg.P.hres_step
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
type lit = Solver_arg.P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = Solver_arg.P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Pre_proof/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Pre_proof/index.html
new file mode 100644
index 00000000..102f6592
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Pre_proof/index.html
@@ -0,0 +1,2 @@
+
+Pre_proof (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Pre_proof)
Module S.Pre_proof
type t = Sidekick_msat_solver.Make(Solver_arg).Pre_proof.t
val output : Stdlib.out_channel -> t -> unit
val pp_debug : t Sidekick_core.Fmt.printer
val pp_dot : t Sidekick_core.Fmt.printer option
val check : t -> unit
val to_proof : t -> P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html
new file mode 100644
index 00000000..feb74dc8
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..edff8087
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html
new file mode 100644
index 00000000..4948b847
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html
new file mode 100644
index 00000000..cd5b8553
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/index.html
new file mode 100644
index 00000000..5af1773d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/index.html
new file mode 100644
index 00000000..f4acd99a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.Lit)
Module Actions.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/P/Quip/index.html
new file mode 100644
index 00000000..b27394bf
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/P/index.html
new file mode 100644
index 00000000..1277ae9f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.P)
Module Actions.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Fun/index.html
new file mode 100644
index 00000000..b9406ed5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html
new file mode 100644
index 00000000..1920c220
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Term/index.html
new file mode 100644
index 00000000..34d0780f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Ty/index.html
new file mode 100644
index 00000000..c0adeb97
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/index.html
new file mode 100644
index 00000000..2bdf1dee
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.T)
Module Actions.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/index.html
new file mode 100644
index 00000000..5cdd42d9
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/index.html
@@ -0,0 +1,2 @@
+
+Actions (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions)
Module CC.Actions
module T : sig ... end
module Lit : sig ... end
module P : sig ... end
type t = actions
val raise_conflict : t -> Lit.t list -> P.t -> 'a
val propagate : t -> Lit.t -> reason:(unit -> Lit.t list * P.t) -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Debug_/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Debug_/index.html
new file mode 100644
index 00000000..8fb326b7
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Debug_/index.html
@@ -0,0 +1,2 @@
+
+Debug_ (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Debug_)
Module CC.Debug_
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Expl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Expl/index.html
new file mode 100644
index 00000000..5895f543
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Expl/index.html
@@ -0,0 +1,2 @@
+
+Expl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Expl)
Module CC.Expl
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.Expl.t
val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t
val mk_merge_t : term -> term -> t
val mk_lit : lit -> t
val mk_list : t list -> t
val mk_proof : P.t -> t
val mk_theory : t -> t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Fun/index.html
new file mode 100644
index 00000000..7dc2e455
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..00653bdd
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Term/index.html
new file mode 100644
index 00000000..1e2f92a5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Ty/index.html
new file mode 100644
index 00000000..00099957
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/index.html
new file mode 100644
index 00000000..84c9d5a5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/index.html
new file mode 100644
index 00000000..1d02a7dc
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Lit)
Module CC.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/N/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/N/index.html
new file mode 100644
index 00000000..e412dce1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/N/index.html
@@ -0,0 +1,2 @@
+
+N (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.N)
Module CC.N
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.N.t
val term : t -> term
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
val is_root : t -> bool
val iter_class : t -> t Iter.t
val iter_parents : t -> t Iter.t
type bitfield = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.N.bitfield
val get_field : bitfield -> t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/P/Quip/index.html
new file mode 100644
index 00000000..cd2f8200
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/P/index.html
new file mode 100644
index 00000000..238955b7
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.P)
Module CC.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Fun/index.html
new file mode 100644
index 00000000..15a1948a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Term/Tbl/index.html
new file mode 100644
index 00000000..ce56f8dd
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Term/index.html
new file mode 100644
index 00000000..cbb58dc5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Ty/index.html
new file mode 100644
index 00000000..7b61912c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/index.html
new file mode 100644
index 00000000..df400ef9
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.T)
Module CC.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/index.html
new file mode 100644
index 00000000..8ac41985
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/index.html
@@ -0,0 +1,2 @@
+
+CC (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC)
Module Solver_internal.CC
module T : sig ... end
module P : sig ... end
module Lit : sig ... end
module Actions : sig ... end
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.t
module N : sig ... end
module Expl : sig ... end
type node = N.t
type repr = N.t
type explanation = Expl.t
val term_store : t -> term_store
val find : t -> node -> repr
val add_term : t -> term -> node
val mem_term : t -> term -> bool
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
type ev_on_new_term = t -> N.t -> term -> unit
type ev_on_conflict = t -> th:bool -> lit list -> unit
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
type ev_on_is_subterm = N.t -> term -> unit
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Big | `Small ] -> term_store -> t
val allocate_bitfield : descr:string -> t -> N.bitfield
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
val on_pre_merge : t -> ev_on_pre_merge -> unit
val on_post_merge : t -> ev_on_post_merge -> unit
val on_new_term : t -> ev_on_new_term -> unit
val on_conflict : t -> ev_on_conflict -> unit
val on_propagate : t -> ev_on_propagate -> unit
val on_is_subterm : t -> ev_on_is_subterm -> unit
val set_as_lit : t -> N.t -> lit -> unit
val find_t : t -> term -> repr
val add_seq : t -> term Iter.t -> unit
val all_classes : t -> repr Iter.t
val assert_lit : t -> lit -> unit
val assert_lits : t -> lit Iter.t -> unit
val explain_eq : t -> N.t -> N.t -> lit list
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
val n_true : t -> N.t
val n_false : t -> N.t
val n_bool : t -> bool -> N.t
val merge : t -> N.t -> N.t -> Expl.t -> unit
val merge_t : t -> term -> term -> Expl.t -> unit
val check : t -> actions -> unit
val new_merges : t -> bool
val push_level : t -> unit
val pop_levels : t -> int -> unit
val get_model : t -> N.t Iter.t Iter.t
module Debug_ : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Fun/index.html
new file mode 100644
index 00000000..6743a2de
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..487e967d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Term/index.html
new file mode 100644
index 00000000..b6ca2629
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Ty/index.html
new file mode 100644
index 00000000..75d774da
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/index.html
new file mode 100644
index 00000000..1eb1337f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/index.html
new file mode 100644
index 00000000..de0b8f0f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Lit)
Module Solver_internal.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/P/Quip/index.html
new file mode 100644
index 00000000..4921b20b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/P/index.html
new file mode 100644
index 00000000..d335dd01
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.P)
Module Solver_internal.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Simplify/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Simplify/index.html
new file mode 100644
index 00000000..82f39c67
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Simplify/index.html
@@ -0,0 +1,2 @@
+
+Simplify (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.Simplify.t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
type hook = t -> term -> (term * proof) option
val normalize : t -> term -> (term * P.t) option
val normalize_t : t -> term -> term * P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Fun/index.html
new file mode 100644
index 00000000..c5d8c55a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Term/Tbl/index.html
new file mode 100644
index 00000000..9f9c5ec1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Term/index.html
new file mode 100644
index 00000000..83d238c8
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Ty/index.html
new file mode 100644
index 00000000..fe41a18f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/index.html
new file mode 100644
index 00000000..f1f132ac
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.T)
Module Solver_internal.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/index.html
new file mode 100644
index 00000000..e80fa754
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/index.html
@@ -0,0 +1,2 @@
+
+Solver_internal (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal)
Module S.Solver_internal
module T : sig ... end
module P : sig ... end
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.t
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
type actions = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.actions
module Lit : sig ... end
type lit = Lit.t
val define_const : t -> const:term -> rhs:term -> unit
module CC : sig ... end
val cc : t -> CC.t
module Simplify : sig ... end
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
val simp_t : t -> term -> term * proof
val raise_conflict : t -> actions -> lit list -> proof -> 'a
val push_decision : t -> actions -> lit -> unit
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
val add_clause_temp : t -> actions -> lit list -> proof -> unit
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
val add_lit : t -> actions -> lit -> unit
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
val cc_find : t -> CC.N.t -> CC.N.t
val cc_are_equal : t -> term -> term -> bool
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
val cc_add_term : t -> term -> CC.N.t
val cc_mem_term : t -> term -> bool
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
val on_preprocess : t -> preprocess_hook -> unit
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
val on_model_gen : t -> model_hook -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Fun/index.html
new file mode 100644
index 00000000..4385252e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_bool.A.S.T.Fun)
Module T.Fun
type t = Solver_arg.T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Term/Tbl/index.html
new file mode 100644
index 00000000..2d2be992
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_bool.A.S.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a Solver_arg.T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Term/index.html
new file mode 100644
index 00000000..f444fd3e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_bool.A.S.T.Term)
Module T.Term
type t = Solver_arg.T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Solver_arg.T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Ty/index.html
new file mode 100644
index 00000000..ca65a110
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_bool.A.S.T.Ty)
Module T.Ty
type t = Solver_arg.T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Solver_arg.T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/index.html
new file mode 100644
index 00000000..30727888
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_bool.A.S.T)
Module S.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Unknown/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Unknown/index.html
new file mode 100644
index 00000000..1ed880d9
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Unknown/index.html
@@ -0,0 +1,2 @@
+
+Unknown (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Unknown)
Module S.Unknown
type t = Sidekick_msat_solver.Make(Solver_arg).Unknown.t
val pp : t CCFormat.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/index.html
new file mode 100644
index 00000000..8c77c6a6
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/index.html
@@ -0,0 +1,2 @@
+
+S (sidekick-base.Sidekick_base_solver.Th_bool.A.S)
Module A.S
module T : sig ... end
module P : sig ... end
module Lit : sig ... end
module Solver_internal : sig ... end
type t = Sidekick_msat_solver.Make(Solver_arg).t
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
type !'a theory_p = (module THEORY with type t = 'a)
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
module Atom : sig ... end
module Model : sig ... end
module Unknown : sig ... end
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Small | `Tiny ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.store -> unit -> t
val add_theory : t -> theory -> unit
val add_theory_p : t -> 'a theory_p -> 'a
val add_theory_l : t -> theory list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> unit
val add_clause_l : t -> Atom.t list -> P.t -> unit
module Pre_proof : sig ... end
type res = Sidekick_msat_solver.Make(Solver_arg).res = 
| Sat of Model.t
| Unsat of {
proof : Pre_proof.t option lazy_t;
unsat_core : Atom.t list lazy_t;
}
| Unknown of Unknown.t
val solve : ?⁠on_exit:(unit -> unit) list -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
val pp_stats : t CCFormat.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/module-type-THEORY/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/module-type-THEORY/index.html
new file mode 100644
index 00000000..72f8d015
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/module-type-THEORY/index.html
@@ -0,0 +1,2 @@
+
+THEORY (sidekick-base.Sidekick_base_solver.Th_bool.A.S.THEORY)
Module type S.THEORY
type t
val name : string
val create_and_setup : Solver_internal.t -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/index.html
new file mode 100644
index 00000000..dbf931b8
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/A/index.html
@@ -0,0 +1,2 @@
+
+A (sidekick-base.Sidekick_base_solver.Th_bool.A)
Module Th_bool.A
module S : sig ... end
type term = S.T.Term.t
val view_as_bool : term -> (term, term Iter.t) Sidekick_th_bool_static.bool_view
val proof_ite_true : S.T.Term.t -> S.P.t
val proof_ite_false : S.T.Term.t -> S.P.t
val proof_bool_eq : S.T.Term.t -> S.T.Term.t -> S.P.t
val proof_bool_c : string -> term list -> S.P.t
val mk_bool : S.T.Term.store -> (term, term Sidekick_util.IArray.t) Sidekick_th_bool_static.bool_view -> term
val check_congruence_classes : bool
module Gensym : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_bool/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_bool/index.html
new file mode 100644
index 00000000..07030d93
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_bool/index.html
@@ -0,0 +1,2 @@
+
+Th_bool (sidekick-base.Sidekick_base_solver.Th_bool)
Module Sidekick_base_solver.Th_bool
Reducing boolean formulas to clauses
module A : sig ... end
type state
val create : A.S.T.Term.store -> A.S.T.Ty.store -> state
val simplify : state -> A.S.Solver_internal.simplify_hook
val cnf : state -> A.S.Solver_internal.preprocess_hook
val theory : A.S.theory

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/Cstor/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/Cstor/index.html
new file mode 100644
index 00000000..25d99ff8
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/Cstor/index.html
@@ -0,0 +1,2 @@
+
+Cstor (sidekick-base.Sidekick_base_solver.Th_data.A.Cstor)
Module A.Cstor
type t = Sidekick_base__Base_types.cstor
val ty_args : t -> S.T.Ty.t Iter.t
val pp : t Sidekick_util.Fmt.printer
val equal : t -> t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Atom/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Atom/index.html
new file mode 100644
index 00000000..5b26eefe
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Atom/index.html
@@ -0,0 +1,2 @@
+
+Atom (sidekick-base.Sidekick_base_solver.Th_data.A.S.Atom)
Module S.Atom
type t = Sidekick_msat_solver.Make(Solver_arg).Atom.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t CCFormat.printer
val neg : t -> t
val formula : t -> lit
val sign : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Fun/index.html
new file mode 100644
index 00000000..9d34334b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_data.A.S.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..8125459c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_data.A.S.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Term/index.html
new file mode 100644
index 00000000..df65e222
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_data.A.S.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Ty/index.html
new file mode 100644
index 00000000..82cbf086
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_data.A.S.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/index.html
new file mode 100644
index 00000000..21e06ada
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_data.A.S.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/index.html
new file mode 100644
index 00000000..706cd32e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Lit)
Module S.Lit
module T : sig ... end
type t = Sidekick_msat_solver.Make(Solver_arg).Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Model/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Model/index.html
new file mode 100644
index 00000000..7978bdab
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Model/index.html
@@ -0,0 +1,2 @@
+
+Model (sidekick-base.Sidekick_base_solver.Th_data.A.S.Model)
Module S.Model
type t = Sidekick_msat_solver.Make(Solver_arg).Model.t
val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/Quip/index.html
new file mode 100644
index 00000000..5c86ff06
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_data.A.S.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/index.html
new file mode 100644
index 00000000..d97e371d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_data.A.S.P)
Module S.P
type t = Solver_arg.P.t
type term = T.Term.t
type ty = Solver_arg.P.ty
type hres_step = Solver_arg.P.hres_step
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
type lit = Solver_arg.P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = Solver_arg.P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Pre_proof/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Pre_proof/index.html
new file mode 100644
index 00000000..1d8e6a63
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Pre_proof/index.html
@@ -0,0 +1,2 @@
+
+Pre_proof (sidekick-base.Sidekick_base_solver.Th_data.A.S.Pre_proof)
Module S.Pre_proof
type t = Sidekick_msat_solver.Make(Solver_arg).Pre_proof.t
val output : Stdlib.out_channel -> t -> unit
val pp_debug : t Sidekick_core.Fmt.printer
val pp_dot : t Sidekick_core.Fmt.printer option
val check : t -> unit
val to_proof : t -> P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html
new file mode 100644
index 00000000..4ffec171
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..18e2af5a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html
new file mode 100644
index 00000000..cbbfa130
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html
new file mode 100644
index 00000000..8a3f0440
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/index.html
new file mode 100644
index 00000000..64750e90
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/index.html
new file mode 100644
index 00000000..0164630e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.Lit)
Module Actions.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/P/Quip/index.html
new file mode 100644
index 00000000..821528ad
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/P/index.html
new file mode 100644
index 00000000..cf2fd545
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.P)
Module Actions.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Fun/index.html
new file mode 100644
index 00000000..20b62fa5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html
new file mode 100644
index 00000000..485065e1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Term/index.html
new file mode 100644
index 00000000..6881dd19
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Ty/index.html
new file mode 100644
index 00000000..26a43139
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/index.html
new file mode 100644
index 00000000..8875a11c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.T)
Module Actions.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/index.html
new file mode 100644
index 00000000..ef1b5ba0
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/index.html
@@ -0,0 +1,2 @@
+
+Actions (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions)
Module CC.Actions
module T : sig ... end
module Lit : sig ... end
module P : sig ... end
type t = actions
val raise_conflict : t -> Lit.t list -> P.t -> 'a
val propagate : t -> Lit.t -> reason:(unit -> Lit.t list * P.t) -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Debug_/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Debug_/index.html
new file mode 100644
index 00000000..4ccb463d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Debug_/index.html
@@ -0,0 +1,2 @@
+
+Debug_ (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Debug_)
Module CC.Debug_
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Expl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Expl/index.html
new file mode 100644
index 00000000..1be61f2f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Expl/index.html
@@ -0,0 +1,2 @@
+
+Expl (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Expl)
Module CC.Expl
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.Expl.t
val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t
val mk_merge_t : term -> term -> t
val mk_lit : lit -> t
val mk_list : t list -> t
val mk_proof : P.t -> t
val mk_theory : t -> t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Fun/index.html
new file mode 100644
index 00000000..783a7d52
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..a1a6b256
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Term/index.html
new file mode 100644
index 00000000..f6328922
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Ty/index.html
new file mode 100644
index 00000000..47f442db
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/index.html
new file mode 100644
index 00000000..a6c32c2a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/index.html
new file mode 100644
index 00000000..4d7c9496
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Lit)
Module CC.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/N/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/N/index.html
new file mode 100644
index 00000000..af5dc5c8
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/N/index.html
@@ -0,0 +1,2 @@
+
+N (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.N)
Module CC.N
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.N.t
val term : t -> term
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
val is_root : t -> bool
val iter_class : t -> t Iter.t
val iter_parents : t -> t Iter.t
type bitfield = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.N.bitfield
val get_field : bitfield -> t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/P/Quip/index.html
new file mode 100644
index 00000000..aedafd7a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/P/index.html
new file mode 100644
index 00000000..6fa906f5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.P)
Module CC.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Fun/index.html
new file mode 100644
index 00000000..e94dd34d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Term/Tbl/index.html
new file mode 100644
index 00000000..f1a2beae
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Term/index.html
new file mode 100644
index 00000000..ba2f48af
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Ty/index.html
new file mode 100644
index 00000000..f2f9a310
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/index.html
new file mode 100644
index 00000000..ac761062
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.T)
Module CC.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/index.html
new file mode 100644
index 00000000..601b8d0c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/index.html
@@ -0,0 +1,2 @@
+
+CC (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC)
Module Solver_internal.CC
module T : sig ... end
module P : sig ... end
module Lit : sig ... end
module Actions : sig ... end
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.t
module N : sig ... end
module Expl : sig ... end
type node = N.t
type repr = N.t
type explanation = Expl.t
val term_store : t -> term_store
val find : t -> node -> repr
val add_term : t -> term -> node
val mem_term : t -> term -> bool
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
type ev_on_new_term = t -> N.t -> term -> unit
type ev_on_conflict = t -> th:bool -> lit list -> unit
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
type ev_on_is_subterm = N.t -> term -> unit
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Big | `Small ] -> term_store -> t
val allocate_bitfield : descr:string -> t -> N.bitfield
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
val on_pre_merge : t -> ev_on_pre_merge -> unit
val on_post_merge : t -> ev_on_post_merge -> unit
val on_new_term : t -> ev_on_new_term -> unit
val on_conflict : t -> ev_on_conflict -> unit
val on_propagate : t -> ev_on_propagate -> unit
val on_is_subterm : t -> ev_on_is_subterm -> unit
val set_as_lit : t -> N.t -> lit -> unit
val find_t : t -> term -> repr
val add_seq : t -> term Iter.t -> unit
val all_classes : t -> repr Iter.t
val assert_lit : t -> lit -> unit
val assert_lits : t -> lit Iter.t -> unit
val explain_eq : t -> N.t -> N.t -> lit list
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
val n_true : t -> N.t
val n_false : t -> N.t
val n_bool : t -> bool -> N.t
val merge : t -> N.t -> N.t -> Expl.t -> unit
val merge_t : t -> term -> term -> Expl.t -> unit
val check : t -> actions -> unit
val new_merges : t -> bool
val push_level : t -> unit
val pop_levels : t -> int -> unit
val get_model : t -> N.t Iter.t Iter.t
module Debug_ : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Fun/index.html
new file mode 100644
index 00000000..11d96636
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..71ad6d8c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Term/index.html
new file mode 100644
index 00000000..cb5f208a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Ty/index.html
new file mode 100644
index 00000000..e782091c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/index.html
new file mode 100644
index 00000000..bdd45e48
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/index.html
new file mode 100644
index 00000000..52a78b39
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Lit)
Module Solver_internal.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/P/Quip/index.html
new file mode 100644
index 00000000..c4628be6
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/P/index.html
new file mode 100644
index 00000000..1bd71403
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.P)
Module Solver_internal.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Simplify/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Simplify/index.html
new file mode 100644
index 00000000..4f5c8966
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Simplify/index.html
@@ -0,0 +1,2 @@
+
+Simplify (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.Simplify.t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
type hook = t -> term -> (term * proof) option
val normalize : t -> term -> (term * P.t) option
val normalize_t : t -> term -> term * P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Fun/index.html
new file mode 100644
index 00000000..1ba6df44
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Term/Tbl/index.html
new file mode 100644
index 00000000..cb85005c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Term/index.html
new file mode 100644
index 00000000..88dd9222
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Ty/index.html
new file mode 100644
index 00000000..20703881
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/index.html
new file mode 100644
index 00000000..fd084de8
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.T)
Module Solver_internal.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/index.html
new file mode 100644
index 00000000..5749c996
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/index.html
@@ -0,0 +1,2 @@
+
+Solver_internal (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal)
Module S.Solver_internal
module T : sig ... end
module P : sig ... end
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.t
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
type actions = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.actions
module Lit : sig ... end
type lit = Lit.t
val define_const : t -> const:term -> rhs:term -> unit
module CC : sig ... end
val cc : t -> CC.t
module Simplify : sig ... end
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
val simp_t : t -> term -> term * proof
val raise_conflict : t -> actions -> lit list -> proof -> 'a
val push_decision : t -> actions -> lit -> unit
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
val add_clause_temp : t -> actions -> lit list -> proof -> unit
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
val add_lit : t -> actions -> lit -> unit
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
val cc_find : t -> CC.N.t -> CC.N.t
val cc_are_equal : t -> term -> term -> bool
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
val cc_add_term : t -> term -> CC.N.t
val cc_mem_term : t -> term -> bool
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
val on_preprocess : t -> preprocess_hook -> unit
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
val on_model_gen : t -> model_hook -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Fun/index.html
new file mode 100644
index 00000000..4be55387
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_data.A.S.T.Fun)
Module T.Fun
type t = Solver_arg.T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Term/Tbl/index.html
new file mode 100644
index 00000000..764e76b7
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_data.A.S.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a Solver_arg.T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Term/index.html
new file mode 100644
index 00000000..8ae9ecc6
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_data.A.S.T.Term)
Module T.Term
type t = Solver_arg.T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Solver_arg.T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Ty/index.html
new file mode 100644
index 00000000..ad01d490
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_data.A.S.T.Ty)
Module T.Ty
type t = Solver_arg.T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Solver_arg.T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/index.html
new file mode 100644
index 00000000..9f727211
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_data.A.S.T)
Module S.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Unknown/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Unknown/index.html
new file mode 100644
index 00000000..d1fd4ca6
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Unknown/index.html
@@ -0,0 +1,2 @@
+
+Unknown (sidekick-base.Sidekick_base_solver.Th_data.A.S.Unknown)
Module S.Unknown
type t = Sidekick_msat_solver.Make(Solver_arg).Unknown.t
val pp : t CCFormat.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/index.html
new file mode 100644
index 00000000..d3d9239b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/index.html
@@ -0,0 +1,2 @@
+
+S (sidekick-base.Sidekick_base_solver.Th_data.A.S)
Module A.S
module T : sig ... end
module P : sig ... end
module Lit : sig ... end
module Solver_internal : sig ... end
type t = Sidekick_msat_solver.Make(Solver_arg).t
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
type !'a theory_p = (module THEORY with type t = 'a)
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
module Atom : sig ... end
module Model : sig ... end
module Unknown : sig ... end
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Small | `Tiny ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.store -> unit -> t
val add_theory : t -> theory -> unit
val add_theory_p : t -> 'a theory_p -> 'a
val add_theory_l : t -> theory list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> unit
val add_clause_l : t -> Atom.t list -> P.t -> unit
module Pre_proof : sig ... end
type res = Sidekick_msat_solver.Make(Solver_arg).res = 
| Sat of Model.t
| Unsat of {
proof : Pre_proof.t option lazy_t;
unsat_core : Atom.t list lazy_t;
}
| Unknown of Unknown.t
val solve : ?⁠on_exit:(unit -> unit) list -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
val pp_stats : t CCFormat.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/module-type-THEORY/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/module-type-THEORY/index.html
new file mode 100644
index 00000000..9acbfe05
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/module-type-THEORY/index.html
@@ -0,0 +1,2 @@
+
+THEORY (sidekick-base.Sidekick_base_solver.Th_data.A.S.THEORY)
Module type S.THEORY
type t
val name : string
val create_and_setup : Solver_internal.t -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/A/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/index.html
new file mode 100644
index 00000000..dd1dd07e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/A/index.html
@@ -0,0 +1,2 @@
+
+A (sidekick-base.Sidekick_base_solver.Th_data.A)
Module Th_data.A
module S : sig ... end
module Cstor : sig ... end
val as_datatype : S.T.Ty.t -> (Cstor.t Iter.t, S.T.Ty.t) Sidekick_th_data.data_ty_view
val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) Sidekick_th_data.data_view
val mk_cstor : S.T.Term.store -> Cstor.t -> S.T.Term.t Sidekick_util.IArray.t -> S.T.Term.t
val mk_is_a : S.T.Term.store -> Cstor.t -> S.T.Term.t -> S.T.Term.t
val mk_sel : S.T.Term.store -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
val mk_eq : S.T.Term.store -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
val ty_is_finite : S.T.Ty.t -> bool
val ty_set_is_finite : S.T.Ty.t -> bool -> unit
val proof_isa_split : S.T.Ty.t -> S.T.Term.t Iter.t -> S.P.t
val proof_isa_disj : S.T.Ty.t -> S.T.Term.t -> S.T.Term.t -> S.P.t
val proof_cstor_inj : Cstor.t -> int -> S.T.Term.t list -> S.T.Term.t list -> S.P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_data/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_data/index.html
new file mode 100644
index 00000000..9193bab0
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_data/index.html
@@ -0,0 +1,2 @@
+
+Th_data (sidekick-base.Sidekick_base_solver.Th_data)
Module Sidekick_base_solver.Th_data
Theory of datatypes
module A : sig ... end
val theory : A.S.theory

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Gensym/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Gensym/index.html
new file mode 100644
index 00000000..15035939
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Gensym/index.html
@@ -0,0 +1,2 @@
+
+Gensym (sidekick-base.Sidekick_base_solver.Th_lra.A.Gensym)
Module A.Gensym
type t
val create : S.T.Term.store -> t
val tst : t -> S.T.Term.store
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html
new file mode 100644
index 00000000..b8b4366a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html
@@ -0,0 +1,2 @@
+
+Q (sidekick-base.Sidekick_base_solver.Th_lra.A.Q)
Module A.Q
type t = Q.t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
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 pp_approx : int -> Stdlib.Format.formatter -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Atom/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Atom/index.html
new file mode 100644
index 00000000..ebb3c8a4
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Atom/index.html
@@ -0,0 +1,2 @@
+
+Atom (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Atom)
Module S.Atom
type t = Sidekick_msat_solver.Make(Solver_arg).Atom.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t CCFormat.printer
val neg : t -> t
val formula : t -> lit
val sign : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Fun/index.html
new file mode 100644
index 00000000..89f69281
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..bb0a455d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/index.html
new file mode 100644
index 00000000..79716cb3
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Ty/index.html
new file mode 100644
index 00000000..a6f89af5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/index.html
new file mode 100644
index 00000000..0c207057
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/index.html
new file mode 100644
index 00000000..c02920cc
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Lit)
Module S.Lit
module T : sig ... end
type t = Sidekick_msat_solver.Make(Solver_arg).Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Model/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Model/index.html
new file mode 100644
index 00000000..011e28e1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Model/index.html
@@ -0,0 +1,2 @@
+
+Model (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Model)
Module S.Model
type t = Sidekick_msat_solver.Make(Solver_arg).Model.t
val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/Quip/index.html
new file mode 100644
index 00000000..3a7a25b1
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_lra.A.S.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/index.html
new file mode 100644
index 00000000..96e28f90
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_lra.A.S.P)
Module S.P
type t = Solver_arg.P.t
type term = T.Term.t
type ty = Solver_arg.P.ty
type hres_step = Solver_arg.P.hres_step
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
type lit = Solver_arg.P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = Solver_arg.P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Pre_proof/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Pre_proof/index.html
new file mode 100644
index 00000000..1cd7066b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Pre_proof/index.html
@@ -0,0 +1,2 @@
+
+Pre_proof (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Pre_proof)
Module S.Pre_proof
type t = Sidekick_msat_solver.Make(Solver_arg).Pre_proof.t
val output : Stdlib.out_channel -> t -> unit
val pp_debug : t Sidekick_core.Fmt.printer
val pp_dot : t Sidekick_core.Fmt.printer option
val check : t -> unit
val to_proof : t -> P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html
new file mode 100644
index 00000000..d8f8446a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..a8af3f9f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html
new file mode 100644
index 00000000..005ad18e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html
new file mode 100644
index 00000000..9c8f58d6
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/index.html
new file mode 100644
index 00000000..659b938a
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/index.html
new file mode 100644
index 00000000..2e1ef15f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.Lit)
Module Actions.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/P/Quip/index.html
new file mode 100644
index 00000000..1a3c678c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/P/index.html
new file mode 100644
index 00000000..f7c1a640
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.P)
Module Actions.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Fun/index.html
new file mode 100644
index 00000000..75e622ea
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html
new file mode 100644
index 00000000..abf2458e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Term/index.html
new file mode 100644
index 00000000..9714b047
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Ty/index.html
new file mode 100644
index 00000000..efdf79f8
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/index.html
new file mode 100644
index 00000000..07a77b4d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.T)
Module Actions.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/index.html
new file mode 100644
index 00000000..cd59d193
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/index.html
@@ -0,0 +1,2 @@
+
+Actions (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions)
Module CC.Actions
module T : sig ... end
module Lit : sig ... end
module P : sig ... end
type t = actions
val raise_conflict : t -> Lit.t list -> P.t -> 'a
val propagate : t -> Lit.t -> reason:(unit -> Lit.t list * P.t) -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Debug_/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Debug_/index.html
new file mode 100644
index 00000000..ffd4e015
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Debug_/index.html
@@ -0,0 +1,2 @@
+
+Debug_ (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Debug_)
Module CC.Debug_
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Expl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Expl/index.html
new file mode 100644
index 00000000..88812899
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Expl/index.html
@@ -0,0 +1,2 @@
+
+Expl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Expl)
Module CC.Expl
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.Expl.t
val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t
val mk_merge_t : term -> term -> t
val mk_lit : lit -> t
val mk_list : t list -> t
val mk_proof : P.t -> t
val mk_theory : t -> t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Fun/index.html
new file mode 100644
index 00000000..51569582
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..4d51f836
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Term/index.html
new file mode 100644
index 00000000..d0f3d135
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Ty/index.html
new file mode 100644
index 00000000..60e18dbd
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/index.html
new file mode 100644
index 00000000..b0d822d3
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/index.html
new file mode 100644
index 00000000..9d8408bb
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Lit)
Module CC.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/N/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/N/index.html
new file mode 100644
index 00000000..5e2e116d
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/N/index.html
@@ -0,0 +1,2 @@
+
+N (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.N)
Module CC.N
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.N.t
val term : t -> term
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
val is_root : t -> bool
val iter_class : t -> t Iter.t
val iter_parents : t -> t Iter.t
type bitfield = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.N.bitfield
val get_field : bitfield -> t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/P/Quip/index.html
new file mode 100644
index 00000000..c7a63641
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/P/index.html
new file mode 100644
index 00000000..180d82a7
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.P)
Module CC.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Fun/index.html
new file mode 100644
index 00000000..1ebc5559
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Term/Tbl/index.html
new file mode 100644
index 00000000..e59f1f87
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Term/index.html
new file mode 100644
index 00000000..81f1a1e9
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Ty/index.html
new file mode 100644
index 00000000..2ec964e0
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/index.html
new file mode 100644
index 00000000..295f57b4
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.T)
Module CC.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/index.html
new file mode 100644
index 00000000..130ef288
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/index.html
@@ -0,0 +1,2 @@
+
+CC (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC)
Module Solver_internal.CC
module T : sig ... end
module P : sig ... end
module Lit : sig ... end
module Actions : sig ... end
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.CC.t
module N : sig ... end
module Expl : sig ... end
type node = N.t
type repr = N.t
type explanation = Expl.t
val term_store : t -> term_store
val find : t -> node -> repr
val add_term : t -> term -> node
val mem_term : t -> term -> bool
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
type ev_on_new_term = t -> N.t -> term -> unit
type ev_on_conflict = t -> th:bool -> lit list -> unit
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
type ev_on_is_subterm = N.t -> term -> unit
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Big | `Small ] -> term_store -> t
val allocate_bitfield : descr:string -> t -> N.bitfield
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
val on_pre_merge : t -> ev_on_pre_merge -> unit
val on_post_merge : t -> ev_on_post_merge -> unit
val on_new_term : t -> ev_on_new_term -> unit
val on_conflict : t -> ev_on_conflict -> unit
val on_propagate : t -> ev_on_propagate -> unit
val on_is_subterm : t -> ev_on_is_subterm -> unit
val set_as_lit : t -> N.t -> lit -> unit
val find_t : t -> term -> repr
val add_seq : t -> term Iter.t -> unit
val all_classes : t -> repr Iter.t
val assert_lit : t -> lit -> unit
val assert_lits : t -> lit Iter.t -> unit
val explain_eq : t -> N.t -> N.t -> lit list
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
val n_true : t -> N.t
val n_false : t -> N.t
val n_bool : t -> bool -> N.t
val merge : t -> N.t -> N.t -> Expl.t -> unit
val merge_t : t -> term -> term -> Expl.t -> unit
val check : t -> actions -> unit
val new_merges : t -> bool
val push_level : t -> unit
val pop_levels : t -> int -> unit
val get_model : t -> N.t Iter.t Iter.t
module Debug_ : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Fun/index.html
new file mode 100644
index 00000000..cd650161
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Lit.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Term/Tbl/index.html
new file mode 100644
index 00000000..893b57b5
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Lit.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Term/index.html
new file mode 100644
index 00000000..f198a344
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Lit.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Ty/index.html
new file mode 100644
index 00000000..48bc1f4b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Lit.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/index.html
new file mode 100644
index 00000000..284cd44f
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Lit.T)
Module Lit.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/index.html
new file mode 100644
index 00000000..e4fe70bc
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/index.html
@@ -0,0 +1,2 @@
+
+Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Lit)
Module Solver_internal.Lit
module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/P/Quip/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/P/Quip/index.html
new file mode 100644
index 00000000..847e3f72
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/P/Quip/index.html
@@ -0,0 +1,2 @@
+
+Quip (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.P.Quip)
Module P.Quip
val output : Stdlib.out_channel -> t -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/P/index.html
new file mode 100644
index 00000000..c7549cf7
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/P/index.html
@@ -0,0 +1,2 @@
+
+P (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.P)
Module Solver_internal.P
type t = P.t
type term = T.Term.t
type ty = P.ty
type hres_step = P.hres_step
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
type lit = P.lit
val pp_lit : lit Sidekick_core.Fmt.printer
val lit_a : term -> lit
val lit_na : term -> lit
val lit_mk : bool -> term -> lit
val lit_eq : term -> term -> lit
val lit_neq : term -> term -> lit
val lit_not : lit -> lit
val lit_sign : lit -> bool
type composite_step = P.composite_step
val stepc : name:string -> lit list -> t -> composite_step
val deft : term -> term -> composite_step
val is_trivial_refl : t -> bool
val assertion : term -> t
val assertion_c : lit Iter.t -> t
val ref_by_name : string -> t
val assertion_c_l : lit list -> t
val hres_iter : t -> hres_step Iter.t -> t
val hres_l : t -> hres_step list -> t
val res : pivot:term -> t -> t -> t
val res1 : t -> t -> t
val refl : term -> t
val true_is_true : t
val true_neq_false : t
val nn : t -> t
val cc_lemma : lit list -> t
val cc_imply2 : t -> t -> term -> term -> t
val cc_imply_l : t list -> term -> term -> t
val composite_iter : ?⁠assms:(string * lit) list -> composite_step Iter.t -> t
val composite_l : ?⁠assms:(string * lit) list -> composite_step list -> t
val sorry : t
val sorry_c : lit Iter.t -> t
val sorry_c_l : lit list -> t
val default : t
val pp_debug : sharing:bool -> t Sidekick_core.Fmt.printer
module Quip : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Simplify/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Simplify/index.html
new file mode 100644
index 00000000..22d04c2e
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Simplify/index.html
@@ -0,0 +1,2 @@
+
+Simplify (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.Simplify.t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
type hook = t -> term -> (term * proof) option
val normalize : t -> term -> (term * P.t) option
val normalize_t : t -> term -> term * P.t

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Fun/index.html
new file mode 100644
index 00000000..2bc50d56
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.T.Fun)
Module T.Fun
type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Term/Tbl/index.html
new file mode 100644
index 00000000..683fd717
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Term/index.html
new file mode 100644
index 00000000..9094d6f0
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.T.Term)
Module T.Term
type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Ty/index.html
new file mode 100644
index 00000000..4f1a82e3
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.T.Ty)
Module T.Ty
type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/index.html
new file mode 100644
index 00000000..a4fcdb81
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.T)
Module Solver_internal.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/index.html
new file mode 100644
index 00000000..d89bf064
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/index.html
@@ -0,0 +1,2 @@
+
+Solver_internal (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal)
Module S.Solver_internal
module T : sig ... end
module P : sig ... end
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.t
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
type actions = Sidekick_msat_solver.Make(Solver_arg).Solver_internal.actions
module Lit : sig ... end
type lit = Lit.t
val define_const : t -> const:term -> rhs:term -> unit
module CC : sig ... end
val cc : t -> CC.t
module Simplify : sig ... end
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
val simp_t : t -> term -> term * proof
val raise_conflict : t -> actions -> lit list -> proof -> 'a
val push_decision : t -> actions -> lit -> unit
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
val add_clause_temp : t -> actions -> lit list -> proof -> unit
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
val add_lit : t -> actions -> lit -> unit
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
val cc_find : t -> CC.N.t -> CC.N.t
val cc_are_equal : t -> term -> term -> bool
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
val cc_add_term : t -> term -> CC.N.t
val cc_mem_term : t -> term -> bool
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
val on_preprocess : t -> preprocess_hook -> unit
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
val on_model_gen : t -> model_hook -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Fun/index.html
new file mode 100644
index 00000000..70f5c4ac
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Fun/index.html
@@ -0,0 +1,2 @@
+
+Fun (sidekick-base.Sidekick_base_solver.Th_lra.A.S.T.Fun)
Module T.Fun
type t = Solver_arg.T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Term/Tbl/index.html
new file mode 100644
index 00000000..47718959
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Term/Tbl/index.html
@@ -0,0 +1,2 @@
+
+Tbl (sidekick-base.Sidekick_base_solver.Th_lra.A.S.T.Term.Tbl)
Module Term.Tbl
type key = t
type !'a t = 'a Solver_arg.T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?⁠by:int -> int t -> key -> unit
val decr : ?⁠by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Term/index.html
new file mode 100644
index 00000000..5a8da800
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Term/index.html
@@ -0,0 +1,2 @@
+
+Term (sidekick-base.Sidekick_base_solver.Th_lra.A.S.T.Term)
Module T.Term
type t = Solver_arg.T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Solver_arg.T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> (t -> t) -> t -> t
val iter_dag : t -> (t -> unit) -> unit
module Tbl : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Ty/index.html
new file mode 100644
index 00000000..e43af852
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/Ty/index.html
@@ -0,0 +1,2 @@
+
+Ty (sidekick-base.Sidekick_base_solver.Th_lra.A.S.T.Ty)
Module T.Ty
type t = Solver_arg.T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Solver_arg.T.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/index.html
new file mode 100644
index 00000000..4f8fca6c
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/T/index.html
@@ -0,0 +1,2 @@
+
+T (sidekick-base.Sidekick_base_solver.Th_lra.A.S.T)
Module S.T
module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Unknown/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Unknown/index.html
new file mode 100644
index 00000000..122949ff
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Unknown/index.html
@@ -0,0 +1,2 @@
+
+Unknown (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Unknown)
Module S.Unknown
type t = Sidekick_msat_solver.Make(Solver_arg).Unknown.t
val pp : t CCFormat.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/index.html
new file mode 100644
index 00000000..67daa566
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/index.html
@@ -0,0 +1,2 @@
+
+S (sidekick-base.Sidekick_base_solver.Th_lra.A.S)
Module A.S
module T : sig ... end
module P : sig ... end
module Lit : sig ... end
module Solver_internal : sig ... end
type t = Sidekick_msat_solver.Make(Solver_arg).t
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
type !'a theory_p = (module THEORY with type t = 'a)
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
module Atom : sig ... end
module Model : sig ... end
module Unknown : sig ... end
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Small | `Tiny ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.store -> unit -> t
val add_theory : t -> theory -> unit
val add_theory_p : t -> 'a theory_p -> 'a
val add_theory_l : t -> theory list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> unit
val add_clause_l : t -> Atom.t list -> P.t -> unit
module Pre_proof : sig ... end
type res = Sidekick_msat_solver.Make(Solver_arg).res = 
| Sat of Model.t
| Unsat of {
proof : Pre_proof.t option lazy_t;
unsat_core : Atom.t list lazy_t;
}
| Unknown of Unknown.t
val solve : ?⁠on_exit:(unit -> unit) list -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
val pp_stats : t CCFormat.printer

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/module-type-THEORY/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/module-type-THEORY/index.html
new file mode 100644
index 00000000..bb0c4361
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/module-type-THEORY/index.html
@@ -0,0 +1,2 @@
+
+THEORY (sidekick-base.Sidekick_base_solver.Th_lra.A.S.THEORY)
Module type S.THEORY
type t
val name : string
val create_and_setup : Solver_internal.t -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/index.html
new file mode 100644
index 00000000..303d814b
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/index.html
@@ -0,0 +1,2 @@
+
+A (sidekick-base.Sidekick_base_solver.Th_lra.A)
Module Th_lra.A
module S : sig ... end
module Q : sig ... end
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> (Q.t, term) Sidekick_arith_lra.lra_view
val mk_bool : S.T.Term.store -> bool -> term
val mk_lra : S.T.Term.store -> (Q.t, term) Sidekick_arith_lra.lra_view -> term
val ty_lra : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term
val has_ty_real : term -> bool
val proof_lra : S.P.lit Iter.t -> S.P.t
val proof_lra_l : S.P.lit list -> S.P.t
module Gensym : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/index.html
new file mode 100644
index 00000000..8da5aabb
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/index.html
@@ -0,0 +1,2 @@
+
+Th_lra (sidekick-base.Sidekick_base_solver.Th_lra)
Module Sidekick_base_solver.Th_lra
Theory of Linear Rational Arithmetic
module A : sig ... end
type state
val create : ?⁠stat:Sidekick_util.Stat.t -> A.S.T.Term.store -> A.S.T.Ty.store -> state
val theory : A.S.theory

\ No newline at end of file
diff --git a/dev/sidekick-base/Sidekick_base_solver/index.html b/dev/sidekick-base/Sidekick_base_solver/index.html
new file mode 100644
index 00000000..0e8602bd
--- /dev/null
+++ b/dev/sidekick-base/Sidekick_base_solver/index.html
@@ -0,0 +1,2 @@
+
+Sidekick_base_solver (sidekick-base.Sidekick_base_solver)
Module Sidekick_base_solver
SMT Solver and Theories for Sidekick_base.
This contains instances of the SMT solver, and theories, from Sidekick_core, using data structures from Sidekick_base.
module Solver_arg : sig ... end
Argument to the SMT solver
module Solver : sig ... end
SMT solver, obtained from Sidekick_msat_solver
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
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory

\ No newline at end of file
diff --git a/dev/sidekick-base/index.html b/dev/sidekick-base/index.html
index 952ff705..f2081070 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.

\ 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.solver
The entry point of this library is the module: Sidekick_base_solver.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/CC/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/CC/index.html
index a29ec2e2..28d48ea8 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/CC/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick-bin.Sidekick_smtlib.Process.Solver.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick-bin.Sidekick_smtlib.Process.Solver.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/Simplify/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/Simplify/index.html
index 0ebcc646..7ecc3271 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/Simplify/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick-bin.Sidekick_smtlib.Process.Solver.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick-bin.Sidekick_smtlib.Process.Solver.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/index.html
index 03c9c0c4..8197c68f 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick-bin.Sidekick_smtlib.Process.Solver.Solver_internal)
Module Solver.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick-bin.Sidekick_smtlib.Process.Solver.Solver_internal)
Module Solver.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Term/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Term/index.html
index 77e57ba5..ae0e1199 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Term/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick-bin.Sidekick_smtlib.Process.Solver.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t = Sidekick_base.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state = Sidekick_base.Term.state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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-bin.Sidekick_smtlib.Process.Solver.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t = Sidekick_base.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Sidekick_base.Term.store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Ty/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Ty/index.html
index 8d288d31..366337e4 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Ty/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick-bin.Sidekick_smtlib.Process.Solver.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t = Sidekick_base.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state = Sidekick_base.Ty.state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick-bin.Sidekick_smtlib.Process.Solver.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t = Sidekick_base.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Sidekick_base.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/index.html
index f79455e2..d5994cd5 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/T/index.html
@@ -1,2 +1,2 @@
 
-T (sidekick-bin.Sidekick_smtlib.Process.Solver.T)
Module Solver.T
module Fun : sig ... end
A function symbol, like "f" or "plus" or "is_human" or "socrates"
module Ty : sig ... end with type t = Sidekick_base.Ty.t and type state = Sidekick_base.Ty.state
Types
module Term : sig ... end with type t = Sidekick_base.Term.t and type state = Sidekick_base.Term.state
Term structure.

\ No newline at end of file
+T (sidekick-bin.Sidekick_smtlib.Process.Solver.T)
Module Solver.T
module Fun : sig ... end
A function symbol, like "f" or "plus" or "is_human" or "socrates"
module Ty : sig ... end with type t = Sidekick_base.Ty.t and type store = Sidekick_base.Ty.store
Types
module Term : sig ... end with type t = Sidekick_base.Term.t and type store = Sidekick_base.Term.store
Term structure.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/index.html
index d96a46eb..c271d0cf 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/Process/Solver/index.html
@@ -1,2 +1,2 @@
 
-Solver (sidekick-bin.Sidekick_smtlib.Process.Solver)
Module Process.Solver
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+Solver (sidekick-bin.Sidekick_smtlib.Process.Solver)
Module Process.Solver
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/index.html
index 85e41998..991d799a 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/Process/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/Process/index.html
@@ -1,2 +1,2 @@
 
-Process (sidekick-bin.Sidekick_smtlib.Process)
Module Sidekick_smtlib.Process
Process Statements
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
type 'a or_error = ('a, string) CCResult.t
module Check_cc : sig ... end
val process_stmt : ?⁠hyps:Solver.Atom.t list Sidekick_util.Vec.t -> ?⁠gc:bool -> ?⁠restarts:bool -> ?⁠pp_cnf:bool -> ?⁠dot_proof:string -> ?⁠proof_file:string -> ?⁠pp_model:bool -> ?⁠check:bool -> ?⁠time:float -> ?⁠memory:float -> ?⁠progress:bool -> Solver.t -> Sidekick_base.Statement.t -> unit or_error

\ No newline at end of file
+Process (sidekick-bin.Sidekick_smtlib.Process)
Module Sidekick_smtlib.Process
Process Statements
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
type 'a or_error = ('a, string) CCResult.t
module Check_cc : sig ... end
val process_stmt : ?⁠hyps:Solver.Atom.t list Sidekick_util.Vec.t -> ?⁠gc:bool -> ?⁠restarts:bool -> ?⁠pp_cnf:bool -> ?⁠dot_proof:string -> ?⁠proof_file:string -> ?⁠pp_model:bool -> ?⁠check:bool -> ?⁠time:float -> ?⁠memory:float -> ?⁠progress:bool -> Solver.t -> Sidekick_base.Statement.t -> unit or_error

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib/index.html b/dev/sidekick-bin/Sidekick_smtlib/index.html
index 2dc5ae19..41a1914a 100644
--- a/dev/sidekick-bin/Sidekick_smtlib/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_smtlib (sidekick-bin.Sidekick_smtlib)
Module Sidekick_smtlib
SMTLib-2 Interface
type 'a or_error = ('a, string) CCResult.t
module Term = Sidekick_base.Term
module Process : sig ... end
module Solver = Process.Solver
val parse : Term.state -> string -> Stmt.t list or_error
val parse_stdin : Term.state -> Stmt.t list or_error

\ No newline at end of file
+Sidekick_smtlib (sidekick-bin.Sidekick_smtlib)
Module Sidekick_smtlib
SMTLib-2 Interface
type 'a or_error = ('a, string) CCResult.t
module Term = Sidekick_base.Term
module Process : sig ... end
module Solver = Process.Solver
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
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Form/Funs/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Form/Funs/index.html
deleted file mode 100644
index 4f536b5d..00000000
--- a/dev/sidekick-bin/Sidekick_smtlib__/Form/Funs/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Funs (sidekick-bin.Sidekick_smtlib__.Form.Funs)
Module Form.Funs
val get_ty : 'a -> 'b -> Sidekick_base.Ty.t
val abs : self:T.t -> 'a -> T.t * bool
val relevant : 'a -> 'b -> 'c -> bool
val eval : Sidekick_base.ID.t -> Sidekick_base.Value.t Sidekick_util.IArray.t -> Sidekick_base.Value.t
val mk_fun : ?⁠do_cc:bool -> Sidekick_base.ID.t -> Sidekick_base.Fun.t
val and_ : Sidekick_base.Fun.t
val or_ : Sidekick_base.Fun.t
val imply : Sidekick_base.Fun.t
val ite : Sidekick_base.Term.state -> Sidekick_base.Term.t -> Sidekick_base.Term.t -> Sidekick_base.Term.t -> Sidekick_base.Term.t

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Form/Gensym/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Form/Gensym/index.html
deleted file mode 100644
index f31fe2cf..00000000
--- a/dev/sidekick-bin/Sidekick_smtlib__/Form/Gensym/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Gensym (sidekick-bin.Sidekick_smtlib__.Form.Gensym)
Module Form.Gensym
type t = {
tst : T.state;
mutable fresh : int;
}
val create : T.state -> t
val fresh_term : t -> pre:string -> Sidekick_base.Ty.t -> T.t

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Form/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Form/index.html
deleted file mode 100644
index 794e3e96..00000000
--- a/dev/sidekick-bin/Sidekick_smtlib__/Form/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Form (sidekick-bin.Sidekick_smtlib__.Form)
Module Sidekick_smtlib__.Form
exception Not_a_th_term
val id_and : Sidekick_base.ID.t
val id_or : Sidekick_base.ID.t
val id_imply : Sidekick_base.ID.t
val view_id : Sidekick_base.ID.t -> 'a Sidekick_util.IArray.t -> ('a, 'a Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
val view_as_bool : T.t -> (T.t, T.t Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
module Funs : sig ... end
val as_id : Sidekick_base.ID.t -> T.t -> T.t Sidekick_util.IArray.t option
val flatten_id : Sidekick_base.ID.t -> bool -> T.t list -> T.t list
val and_l : T.state -> T.t list -> T.t
val or_l : T.state -> T.t list -> T.t
val and_ : T.state -> T.t -> T.t -> T.t
val or_ : T.state -> T.t -> T.t -> T.t
val and_a : T.state -> T.t Sidekick_util.IArray.t -> T.t
val or_a : T.state -> T.t Sidekick_util.IArray.t -> T.t
val eq : T.state -> T.t -> T.t -> T.t
val not_ : T.state -> T.t -> T.t
val ite : T.state -> T.t -> T.t -> T.t -> T.t
val equiv : T.state -> T.t -> T.t -> T.t
val neq : T.state -> T.t -> T.t -> T.t
val imply_a : T.state -> T.t Sidekick_util.IArray.t -> T.t -> T.t
val imply_l : T.state -> T.t list -> T.t -> T.t
val imply : T.state -> T.t -> T.t -> T.t
val xor : T.state -> T.t -> T.t -> T.t
val distinct_l : T.state -> T.t CCList.t -> T.t
val mk_bool : T.state -> (T.t, T.t Sidekick_util.IArray.t) Sidekick_th_bool_static.bool_view -> T.t
module Gensym : sig ... end
val check_congruence_classes : bool

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/CC/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/CC/index.html
index 40aaaaaa..6e22f9cc 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/CC/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick-bin.Sidekick_smtlib__.Process.Solver.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick-bin.Sidekick_smtlib__.Process.Solver.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/Simplify/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/Simplify/index.html
index a8cd544e..781958e9 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/Simplify/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick-bin.Sidekick_smtlib__.Process.Solver.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick-bin.Sidekick_smtlib__.Process.Solver.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/index.html
index 956deaf8..bed51bae 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick-bin.Sidekick_smtlib__.Process.Solver.Solver_internal)
Module Solver.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick-bin.Sidekick_smtlib__.Process.Solver.Solver_internal)
Module Solver.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/Term/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/Term/index.html
index 1ef3b049..2194d721 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/Term/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick-bin.Sidekick_smtlib__.Process.Solver.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t = Sidekick_base.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state = Sidekick_base.Term.state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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-bin.Sidekick_smtlib__.Process.Solver.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t = Sidekick_base.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Sidekick_base.Term.store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/Ty/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/Ty/index.html
index ba71f4e2..a30f4b2e 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/Ty/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick-bin.Sidekick_smtlib__.Process.Solver.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t = Sidekick_base.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state = Sidekick_base.Ty.state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick-bin.Sidekick_smtlib__.Process.Solver.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t = Sidekick_base.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Sidekick_base.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/index.html
index 114f5b33..f4bc5b38 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/T/index.html
@@ -1,2 +1,2 @@
 
-T (sidekick-bin.Sidekick_smtlib__.Process.Solver.T)
Module Solver.T
module Fun : sig ... end
A function symbol, like "f" or "plus" or "is_human" or "socrates"
module Ty : sig ... end with type t = Sidekick_base.Ty.t and type state = Sidekick_base.Ty.state
Types
module Term : sig ... end with type t = Sidekick_base.Term.t and type state = Sidekick_base.Term.state
Term structure.

\ No newline at end of file
+T (sidekick-bin.Sidekick_smtlib__.Process.Solver.T)
Module Solver.T
module Fun : sig ... end
A function symbol, like "f" or "plus" or "is_human" or "socrates"
module Ty : sig ... end with type t = Sidekick_base.Ty.t and type store = Sidekick_base.Ty.store
Types
module Term : sig ... end with type t = Sidekick_base.Term.t and type store = Sidekick_base.Term.store
Term structure.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/index.html
index 91fae815..aaf71ce2 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/index.html
@@ -1,2 +1,2 @@
 
-Solver (sidekick-bin.Sidekick_smtlib__.Process.Solver)
Module Process.Solver
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+Solver (sidekick-bin.Sidekick_smtlib__.Process.Solver)
Module Process.Solver
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Process/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Process/index.html
index 05218ce1..9d4d0256 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Process/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Process/index.html
@@ -1,2 +1,2 @@
 
-Process (sidekick-bin.Sidekick_smtlib__.Process)
Module Sidekick_smtlib__.Process
Process Statements
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
type 'a or_error = ('a, string) CCResult.t
module Check_cc : sig ... end
val process_stmt : ?⁠hyps:Solver.Atom.t list Sidekick_util.Vec.t -> ?⁠gc:bool -> ?⁠restarts:bool -> ?⁠pp_cnf:bool -> ?⁠dot_proof:string -> ?⁠proof_file:string -> ?⁠pp_model:bool -> ?⁠check:bool -> ?⁠time:float -> ?⁠memory:float -> ?⁠progress:bool -> Solver.t -> Sidekick_base.Statement.t -> unit or_error

\ No newline at end of file
+Process (sidekick-bin.Sidekick_smtlib__.Process)
Module Sidekick_smtlib__.Process
Process Statements
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
type 'a or_error = ('a, string) CCResult.t
module Check_cc : sig ... end
val process_stmt : ?⁠hyps:Solver.Atom.t list Sidekick_util.Vec.t -> ?⁠gc:bool -> ?⁠restarts:bool -> ?⁠pp_cnf:bool -> ?⁠dot_proof:string -> ?⁠proof_file:string -> ?⁠pp_model:bool -> ?⁠check:bool -> ?⁠time:float -> ?⁠memory:float -> ?⁠progress:bool -> Solver.t -> Sidekick_base.Statement.t -> unit or_error

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/Typecheck/Ctx/index.html b/dev/sidekick-bin/Sidekick_smtlib__/Typecheck/Ctx/index.html
index dc9c4b93..ade1c3d1 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/Typecheck/Ctx/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/Typecheck/Ctx/index.html
@@ -1,2 +1,2 @@
 
-Ctx (sidekick-bin.Sidekick_smtlib__.Typecheck.Ctx)
Module Typecheck.Ctx
type t
val create : T.state -> t

\ No newline at end of file
+Ctx (sidekick-bin.Sidekick_smtlib__.Typecheck.Ctx)
Module Typecheck.Ctx
type t
val create : T.store -> t

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__/index.html b/dev/sidekick-bin/Sidekick_smtlib__/index.html
index 721a730f..f03a1fc1 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_smtlib__ (sidekick-bin.Sidekick_smtlib__)
Module Sidekick_smtlib__
module Form : sig ... end
module Process : sig ... end
module Typecheck : sig ... end

\ No newline at end of file
+Sidekick_smtlib__ (sidekick-bin.Sidekick_smtlib__)
Module Sidekick_smtlib__
module Process : sig ... end
module Typecheck : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Form/Funs/index.html b/dev/sidekick-bin/Sidekick_smtlib__Form/Funs/index.html
deleted file mode 100644
index 4bc65fc1..00000000
--- a/dev/sidekick-bin/Sidekick_smtlib__Form/Funs/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Funs (sidekick-bin.Sidekick_smtlib__Form.Funs)
Module Sidekick_smtlib__Form.Funs
val get_ty : 'a -> 'b -> Sidekick_base.Ty.t
val abs : self:T.t -> 'a -> T.t * bool
val relevant : 'a -> 'b -> 'c -> bool
val eval : Sidekick_base.ID.t -> Sidekick_base.Value.t Sidekick_util.IArray.t -> Sidekick_base.Value.t
val mk_fun : ?⁠do_cc:bool -> Sidekick_base.ID.t -> Sidekick_base.Fun.t
val and_ : Sidekick_base.Fun.t
val or_ : Sidekick_base.Fun.t
val imply : Sidekick_base.Fun.t
val ite : Sidekick_base.Term.state -> Sidekick_base.Term.t -> Sidekick_base.Term.t -> Sidekick_base.Term.t -> Sidekick_base.Term.t

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Form/Gensym/index.html b/dev/sidekick-bin/Sidekick_smtlib__Form/Gensym/index.html
deleted file mode 100644
index 0f996495..00000000
--- a/dev/sidekick-bin/Sidekick_smtlib__Form/Gensym/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Gensym (sidekick-bin.Sidekick_smtlib__Form.Gensym)
Module Sidekick_smtlib__Form.Gensym
type t = {
tst : T.state;
mutable fresh : int;
}
val create : T.state -> t
val fresh_term : t -> pre:string -> Sidekick_base.Ty.t -> T.t

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Form/index.html b/dev/sidekick-bin/Sidekick_smtlib__Form/index.html
deleted file mode 100644
index 525ba85b..00000000
--- a/dev/sidekick-bin/Sidekick_smtlib__Form/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Sidekick_smtlib__Form (sidekick-bin.Sidekick_smtlib__Form)
Module Sidekick_smtlib__Form
exception Not_a_th_term
val id_and : Sidekick_base.ID.t
val id_or : Sidekick_base.ID.t
val id_imply : Sidekick_base.ID.t
val view_id : Sidekick_base.ID.t -> 'a Sidekick_util.IArray.t -> ('a, 'a Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
val view_as_bool : T.t -> (T.t, T.t Sidekick_util.IArray.iter) Sidekick_th_bool_static.bool_view
module Funs : sig ... end
val as_id : Sidekick_base.ID.t -> T.t -> T.t Sidekick_util.IArray.t option
val flatten_id : Sidekick_base.ID.t -> bool -> T.t list -> T.t list
val and_l : T.state -> T.t list -> T.t
val or_l : T.state -> T.t list -> T.t
val and_ : T.state -> T.t -> T.t -> T.t
val or_ : T.state -> T.t -> T.t -> T.t
val and_a : T.state -> T.t Sidekick_util.IArray.t -> T.t
val or_a : T.state -> T.t Sidekick_util.IArray.t -> T.t
val eq : T.state -> T.t -> T.t -> T.t
val not_ : T.state -> T.t -> T.t
val ite : T.state -> T.t -> T.t -> T.t -> T.t
val equiv : T.state -> T.t -> T.t -> T.t
val neq : T.state -> T.t -> T.t -> T.t
val imply_a : T.state -> T.t Sidekick_util.IArray.t -> T.t -> T.t
val imply_l : T.state -> T.t list -> T.t -> T.t
val imply : T.state -> T.t -> T.t -> T.t
val xor : T.state -> T.t -> T.t -> T.t
val distinct_l : T.state -> T.t CCList.t -> T.t
val mk_bool : T.state -> (T.t, T.t Sidekick_util.IArray.t) Sidekick_th_bool_static.bool_view -> T.t
module Gensym : sig ... end
val check_congruence_classes : bool

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/CC/index.html b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/CC/index.html
index cec28982..9afb439d 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/CC/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick-bin.Sidekick_smtlib__Process.Solver.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick-bin.Sidekick_smtlib__Process.Solver.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/Simplify/index.html b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/Simplify/index.html
index 472c60cd..ff8fdb64 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/Simplify/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick-bin.Sidekick_smtlib__Process.Solver.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick-bin.Sidekick_smtlib__Process.Solver.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/index.html b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/index.html
index 93345163..285f7945 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick-bin.Sidekick_smtlib__Process.Solver.Solver_internal)
Module Solver.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick-bin.Sidekick_smtlib__Process.Solver.Solver_internal)
Module Solver.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/Term/index.html b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/Term/index.html
index 2f92b3e8..2ef6386b 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/Term/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick-bin.Sidekick_smtlib__Process.Solver.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t = Sidekick_base.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state = Sidekick_base.Term.state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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-bin.Sidekick_smtlib__Process.Solver.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t = Sidekick_base.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Sidekick_base.Term.store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/Ty/index.html b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/Ty/index.html
index 51cf0f3a..c5d89725 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/Ty/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick-bin.Sidekick_smtlib__Process.Solver.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t = Sidekick_base.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state = Sidekick_base.Ty.state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick-bin.Sidekick_smtlib__Process.Solver.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t = Sidekick_base.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = Sidekick_base.Ty.store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/index.html b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/index.html
index 1fc2cf78..d3b6d7cb 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/T/index.html
@@ -1,2 +1,2 @@
 
-T (sidekick-bin.Sidekick_smtlib__Process.Solver.T)
Module Solver.T
module Fun : sig ... end
A function symbol, like "f" or "plus" or "is_human" or "socrates"
module Ty : sig ... end with type t = Sidekick_base.Ty.t and type state = Sidekick_base.Ty.state
Types
module Term : sig ... end with type t = Sidekick_base.Term.t and type state = Sidekick_base.Term.state
Term structure.

\ No newline at end of file
+T (sidekick-bin.Sidekick_smtlib__Process.Solver.T)
Module Solver.T
module Fun : sig ... end
A function symbol, like "f" or "plus" or "is_human" or "socrates"
module Ty : sig ... end with type t = Sidekick_base.Ty.t and type store = Sidekick_base.Ty.store
Types
module Term : sig ... end with type t = Sidekick_base.Term.t and type store = Sidekick_base.Term.store
Term structure.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/index.html b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/index.html
index c986e46c..673a055a 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Process/Solver/index.html
@@ -1,2 +1,2 @@
 
-Solver (sidekick-bin.Sidekick_smtlib__Process.Solver)
Module Sidekick_smtlib__Process.Solver
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+Solver (sidekick-bin.Sidekick_smtlib__Process.Solver)
Module Sidekick_smtlib__Process.Solver
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Process/index.html b/dev/sidekick-bin/Sidekick_smtlib__Process/index.html
index c016fa44..cdf24f4d 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Process/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Process/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_smtlib__Process (sidekick-bin.Sidekick_smtlib__Process)
Module Sidekick_smtlib__Process
Process Statements
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
type 'a or_error = ('a, string) CCResult.t
module Check_cc : sig ... end
val process_stmt : ?⁠hyps:Solver.Atom.t list Sidekick_util.Vec.t -> ?⁠gc:bool -> ?⁠restarts:bool -> ?⁠pp_cnf:bool -> ?⁠dot_proof:string -> ?⁠proof_file:string -> ?⁠pp_model:bool -> ?⁠check:bool -> ?⁠time:float -> ?⁠memory:float -> ?⁠progress:bool -> Solver.t -> Sidekick_base.Statement.t -> unit or_error

\ No newline at end of file
+Sidekick_smtlib__Process (sidekick-bin.Sidekick_smtlib__Process)
Module Sidekick_smtlib__Process
Process Statements
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
type 'a or_error = ('a, string) CCResult.t
module Check_cc : sig ... end
val process_stmt : ?⁠hyps:Solver.Atom.t list Sidekick_util.Vec.t -> ?⁠gc:bool -> ?⁠restarts:bool -> ?⁠pp_cnf:bool -> ?⁠dot_proof:string -> ?⁠proof_file:string -> ?⁠pp_model:bool -> ?⁠check:bool -> ?⁠time:float -> ?⁠memory:float -> ?⁠progress:bool -> Solver.t -> Sidekick_base.Statement.t -> unit or_error

\ No newline at end of file
diff --git a/dev/sidekick-bin/Sidekick_smtlib__Typecheck/Ctx/index.html b/dev/sidekick-bin/Sidekick_smtlib__Typecheck/Ctx/index.html
index 9f207d14..042b2d91 100644
--- a/dev/sidekick-bin/Sidekick_smtlib__Typecheck/Ctx/index.html
+++ b/dev/sidekick-bin/Sidekick_smtlib__Typecheck/Ctx/index.html
@@ -1,2 +1,2 @@
 
-Ctx (sidekick-bin.Sidekick_smtlib__Typecheck.Ctx)
Module Sidekick_smtlib__Typecheck.Ctx
type t
val create : T.state -> t

\ No newline at end of file
+Ctx (sidekick-bin.Sidekick_smtlib__Typecheck.Ctx)
Module Sidekick_smtlib__Typecheck.Ctx
type t
val create : T.store -> t

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/Gensym/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/Gensym/index.html
index 65b4c554..811d70d7 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/Gensym/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/Gensym/index.html
@@ -1,2 +1,2 @@
 
-Gensym (sidekick.Sidekick_arith_lra.Make.1-A.Gensym)
Module 1-A.Gensym
type t
val create : S.T.Term.state -> t
val tst : t -> S.T.Term.state
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
+Gensym (sidekick.Sidekick_arith_lra.Make.1-A.Gensym)
Module 1-A.Gensym
type t
val create : S.T.Term.store -> t
val tst : t -> S.T.Term.store
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/CC/index.html
index af08f5d1..8be82bac 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_arith_lra.Make.1-A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_arith_lra.Make.1-A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/Simplify/index.html
index 3d1238b7..83488d66 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_arith_lra.Make.1-A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_arith_lra.Make.1-A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/index.html
index 8a51a1f9..3b4c9abf 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_arith_lra.Make.1-A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_arith_lra.Make.1-A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/T/Term/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/T/Term/index.html
index 004478cb..c4203cbb 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_arith_lra.Make.1-A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_arith_lra.Make.1-A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/T/Ty/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/T/Ty/index.html
index b24cd2f6..159c79e8 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_arith_lra.Make.1-A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_arith_lra.Make.1-A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/index.html
index 22b6d790..232eca67 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_arith_lra.Make.1-A.S)
Module 1-A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_arith_lra.Make.1-A.S)
Module 1-A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/index.html
index f0d33542..a567ad89 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/index.html
@@ -1,2 +1,2 @@
 
-1-A (sidekick.Sidekick_arith_lra.Make.1-A)
Parameter Make.1-A
module Q : RATIONAL
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> (Q.t, term) lra_view
Project the term into the theory view
val mk_bool : S.T.Term.state -> bool -> term
val mk_lra : S.T.Term.state -> (Q.t, term) lra_view -> term
Make a term from the given theory view
val ty_lra : S.T.Term.state -> ty
val mk_eq : S.T.Term.state -> term -> term -> term
syntactic equality
val has_ty_real : term -> bool
Does this term have the type Real
val proof_lra : S.P.lit Iter.t -> S.P.t
TODO: more accurate certificates
val proof_lra_l : S.P.lit list -> S.P.t
module Gensym : sig ... end

\ No newline at end of file
+1-A (sidekick.Sidekick_arith_lra.Make.1-A)
Parameter Make.1-A
module Q : RATIONAL
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> (Q.t, term) lra_view
Project the term into the theory view
val mk_bool : S.T.Term.store -> bool -> term
val mk_lra : S.T.Term.store -> (Q.t, term) lra_view -> term
Make a term from the given theory view
val ty_lra : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term
syntactic equality
val has_ty_real : term -> bool
Does this term have the type Real
val proof_lra : S.P.lit Iter.t -> S.P.t
TODO: more accurate certificates
val proof_lra_l : S.P.lit list -> S.P.t
module Gensym : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/Make/index.html b/dev/sidekick/Sidekick_arith_lra/Make/index.html
index 3910f844..1f297137 100644
--- a/dev/sidekick/Sidekick_arith_lra/Make/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_arith_lra.Make)
Module Sidekick_arith_lra.Make
Parameters
Signature
module A = A
type state
val create : ?⁠stat:Sidekick_util.Stat.t -> A.S.T.Term.state -> A.S.T.Ty.state -> state
val theory : A.S.theory

\ No newline at end of file
+Make (sidekick.Sidekick_arith_lra.Make)
Module Sidekick_arith_lra.Make
Parameters
Signature
module A = A
type state
val create : ?⁠stat:Sidekick_util.Stat.t -> A.S.T.Term.store -> A.S.T.Ty.store -> state
val theory : A.S.theory

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/Gensym/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/Gensym/index.html
index 09d9fcf1..dc1a8ab1 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/Gensym/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/Gensym/index.html
@@ -1,2 +1,2 @@
 
-Gensym (sidekick.Sidekick_arith_lra.ARG.Gensym)
Module ARG.Gensym
type t
val create : S.T.Term.state -> t
val tst : t -> S.T.Term.state
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
+Gensym (sidekick.Sidekick_arith_lra.ARG.Gensym)
Module ARG.Gensym
type t
val create : S.T.Term.store -> t
val tst : t -> S.T.Term.store
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/CC/index.html
index 4002af35..31838fe8 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_arith_lra.ARG.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_arith_lra.ARG.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/Simplify/index.html
index 8f062ac1..ad01ff44 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_arith_lra.ARG.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_arith_lra.ARG.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/index.html
index 84695880..bc7cd98e 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_arith_lra.ARG.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_arith_lra.ARG.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/T/Term/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/T/Term/index.html
index bafaf489..4a1d2506 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_arith_lra.ARG.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_arith_lra.ARG.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/T/Ty/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/T/Ty/index.html
index cb5c4a99..3a25c18c 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_arith_lra.ARG.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_arith_lra.ARG.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/index.html
index d8f687fb..d4e1ec89 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_arith_lra.ARG.S)
Module ARG.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_arith_lra.ARG.S)
Module ARG.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/index.html
index c60cdb38..5eb58bab 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_arith_lra.ARG)
Module type Sidekick_arith_lra.ARG
module Q : RATIONAL
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> (Q.t, term) lra_view
Project the term into the theory view
val mk_bool : S.T.Term.state -> bool -> term
val mk_lra : S.T.Term.state -> (Q.t, term) lra_view -> term
Make a term from the given theory view
val ty_lra : S.T.Term.state -> ty
val mk_eq : S.T.Term.state -> term -> term -> term
syntactic equality
val has_ty_real : term -> bool
Does this term have the type Real
val proof_lra : S.P.lit Iter.t -> S.P.t
TODO: more accurate certificates
val proof_lra_l : S.P.lit list -> S.P.t
module Gensym : sig ... end

\ No newline at end of file
+ARG (sidekick.Sidekick_arith_lra.ARG)
Module type Sidekick_arith_lra.ARG
module Q : RATIONAL
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> (Q.t, term) lra_view
Project the term into the theory view
val mk_bool : S.T.Term.store -> bool -> term
val mk_lra : S.T.Term.store -> (Q.t, term) lra_view -> term
Make a term from the given theory view
val ty_lra : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term
syntactic equality
val has_ty_real : term -> bool
Does this term have the type Real
val proof_lra : S.P.lit Iter.t -> S.P.t
TODO: more accurate certificates
val proof_lra_l : S.P.lit list -> S.P.t
module Gensym : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/Gensym/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/Gensym/index.html
index cb8edcbd..580e8521 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/Gensym/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/Gensym/index.html
@@ -1,2 +1,2 @@
 
-Gensym (sidekick.Sidekick_arith_lra.S.A.Gensym)
Module A.Gensym
type t
val create : S.T.Term.state -> t
val tst : t -> S.T.Term.state
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
+Gensym (sidekick.Sidekick_arith_lra.S.A.Gensym)
Module A.Gensym
type t
val create : S.T.Term.store -> t
val tst : t -> S.T.Term.store
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/CC/index.html
index fbc865e9..f07cd5b5 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_arith_lra.S.A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_arith_lra.S.A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/Simplify/index.html
index 5cd2790e..fed06f78 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_arith_lra.S.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_arith_lra.S.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/index.html
index 5eb7d392..0eecd434 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_arith_lra.S.A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_arith_lra.S.A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/T/Term/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/T/Term/index.html
index 04957adc..1a61e8b1 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_arith_lra.S.A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_arith_lra.S.A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/T/Ty/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/T/Ty/index.html
index 4b0a7de6..7ad6670b 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_arith_lra.S.A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_arith_lra.S.A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/index.html
index 8c33e93f..553fceb7 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_arith_lra.S.A.S)
Module A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_arith_lra.S.A.S)
Module A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/index.html
index c920d348..b9159566 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/index.html
@@ -1,2 +1,2 @@
 
-A (sidekick.Sidekick_arith_lra.S.A)
Module S.A
module Q : RATIONAL
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> (Q.t, term) lra_view
Project the term into the theory view
val mk_bool : S.T.Term.state -> bool -> term
val mk_lra : S.T.Term.state -> (Q.t, term) lra_view -> term
Make a term from the given theory view
val ty_lra : S.T.Term.state -> ty
val mk_eq : S.T.Term.state -> term -> term -> term
syntactic equality
val has_ty_real : term -> bool
Does this term have the type Real
val proof_lra : S.P.lit Iter.t -> S.P.t
TODO: more accurate certificates
val proof_lra_l : S.P.lit list -> S.P.t
module Gensym : sig ... end

\ No newline at end of file
+A (sidekick.Sidekick_arith_lra.S.A)
Module S.A
module Q : RATIONAL
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> (Q.t, term) lra_view
Project the term into the theory view
val mk_bool : S.T.Term.store -> bool -> term
val mk_lra : S.T.Term.store -> (Q.t, term) lra_view -> term
Make a term from the given theory view
val ty_lra : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term
syntactic equality
val has_ty_real : term -> bool
Does this term have the type Real
val proof_lra : S.P.lit Iter.t -> S.P.t
TODO: more accurate certificates
val proof_lra_l : S.P.lit list -> S.P.t
module Gensym : sig ... end

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/index.html
index fb0a59cc..62b897c9 100644
--- a/dev/sidekick/Sidekick_arith_lra/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_arith_lra.S)
Module type Sidekick_arith_lra.S
module A : ARG
type state
val create : ?⁠stat:Sidekick_util.Stat.t -> A.S.T.Term.state -> A.S.T.Ty.state -> state
val theory : A.S.theory

\ No newline at end of file
+S (sidekick.Sidekick_arith_lra.S)
Module type Sidekick_arith_lra.S
module A : ARG
type state
val create : ?⁠stat:Sidekick_util.Stat.t -> A.S.T.Term.store -> A.S.T.Ty.store -> state
val theory : A.S.theory

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Term/index.html b/dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Term/index.html
index 455ced84..92ba685f 100644
--- a/dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Term/index.html
+++ b/dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_cc.Make.1-A.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_cc.Make.1-A.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Ty/index.html b/dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Ty/index.html
index db4f2bd3..144f3660 100644
--- a/dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_cc/Make/argument-1-A/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_cc.Make.1-A.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_cc.Make.1-A.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_cc/Make/index.html b/dev/sidekick/Sidekick_cc/Make/index.html
index a1cb736b..936d3b33 100644
--- a/dev/sidekick/Sidekick_cc/Make/index.html
+++ b/dev/sidekick/Sidekick_cc/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_cc.Make)
Module Sidekick_cc.Make
Parameters
Signature
module T = A.T
module P = A.P
module Lit = A.Lit
module Actions = A.Actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+Make (sidekick.Sidekick_cc.Make)
Module Sidekick_cc.Make
Parameters
Signature
module T = A.T
module P = A.P
module Lit = A.Lit
module Actions = A.Actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_cc/module-type-S/T/Term/index.html b/dev/sidekick/Sidekick_cc/module-type-S/T/Term/index.html
index 9e51a4a5..24cc2667 100644
--- a/dev/sidekick/Sidekick_cc/module-type-S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_cc.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_cc.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_cc/module-type-S/T/Ty/index.html b/dev/sidekick/Sidekick_cc/module-type-S/T/Ty/index.html
index 35c8f779..d2fb0a7c 100644
--- a/dev/sidekick/Sidekick_cc/module-type-S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_cc.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_cc.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_cc/module-type-S/index.html b/dev/sidekick/Sidekick_cc/module-type-S/index.html
index 4b3551b6..ec4c0e01 100644
--- a/dev/sidekick/Sidekick_cc/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_cc.S)
Module type Sidekick_cc.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+S (sidekick.Sidekick_cc.S)
Module type Sidekick_cc.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/CC/index.html b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/CC/index.html
index f529bfa9..817db53f 100644
--- a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/CC/index.html
+++ b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.CC)
Module SI.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.CC)
Module SI.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/Simplify/index.html b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/Simplify/index.html
index 845a51aa..2df89828 100644
--- a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/Simplify/index.html
+++ b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.Simplify)
Module SI.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.Simplify)
Module SI.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/T/Term/index.html b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/T/Term/index.html
index ac8a1cf5..950647c2 100644
--- a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/T/Term/index.html
+++ b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.Monoid_of_repr.1-M.SI.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/T/Ty/index.html b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/T/Ty/index.html
index a190ac83..c8a28ed2 100644
--- a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/index.html b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/index.html
index 6c8af844..a32a66d1 100644
--- a/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/index.html
+++ b/dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/index.html
@@ -1,2 +1,2 @@
 
-SI (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI)
Module 1-M.SI
module T : TERM
module P : PROOF with type term = T.Term.t
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit : LIT with module T = T
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+SI (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI)
Module 1-M.SI
module T : TERM
module P : PROOF with type term = T.Term.t
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit : LIT with module T = T
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/T/Term/index.html b/dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/T/Term/index.html
index 9971d00b..b28098b1 100644
--- a/dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/T/Term/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.CC_ACTIONS.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.CC_ACTIONS.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/T/Ty/index.html b/dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/T/Ty/index.html
index a2bcdc75..a41594ae 100644
--- a/dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.CC_ACTIONS.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.CC_ACTIONS.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Term/index.html b/dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Term/index.html
index e2e456ef..3dfd7ee2 100644
--- a/dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Term/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.CC_ARG.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.CC_ARG.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Ty/index.html b/dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Ty/index.html
index bc55619a..119de0f0 100644
--- a/dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-CC_ARG/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.CC_ARG.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.CC_ARG.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-CC_S/T/Term/index.html b/dev/sidekick/Sidekick_core/module-type-CC_S/T/Term/index.html
index 2d0e4dfd..64cbc6b3 100644
--- a/dev/sidekick/Sidekick_core/module-type-CC_S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-CC_S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.CC_S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.CC_S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/module-type-CC_S/T/Ty/index.html b/dev/sidekick/Sidekick_core/module-type-CC_S/T/Ty/index.html
index f8dfee11..66fc353e 100644
--- a/dev/sidekick/Sidekick_core/module-type-CC_S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-CC_S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.CC_S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.CC_S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-CC_S/index.html b/dev/sidekick/Sidekick_core/module-type-CC_S/index.html
index 05422c36..f15bbbfe 100644
--- a/dev/sidekick/Sidekick_core/module-type-CC_S/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-CC_S/index.html
@@ -1,2 +1,2 @@
 
-CC_S (sidekick.Sidekick_core.CC_S)
Module type Sidekick_core.CC_S
Signature of the congruence closure
module T : TERM
module P : PROOF with type term = T.Term.t
module Lit : LIT with module T = T
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC_S (sidekick.Sidekick_core.CC_S)
Module type Sidekick_core.CC_S
Signature of the congruence closure
module T : TERM
module P : PROOF with type term = T.Term.t
module Lit : LIT with module T = T
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-LIT/T/Term/index.html b/dev/sidekick/Sidekick_core/module-type-LIT/T/Term/index.html
index 6322b848..07af6c08 100644
--- a/dev/sidekick/Sidekick_core/module-type-LIT/T/Term/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-LIT/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.LIT.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.LIT.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/module-type-LIT/T/Ty/index.html b/dev/sidekick/Sidekick_core/module-type-LIT/T/Ty/index.html
index f0156188..db221ea5 100644
--- a/dev/sidekick/Sidekick_core/module-type-LIT/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-LIT/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.LIT.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.LIT.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/CC/index.html b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/CC/index.html
index 4d4c73a5..8400f6aa 100644
--- a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/CC/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_core.MONOID_ARG.SI.CC)
Module SI.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_core.MONOID_ARG.SI.CC)
Module SI.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/Simplify/index.html b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/Simplify/index.html
index ae73b50e..2ef787af 100644
--- a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/Simplify/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_core.MONOID_ARG.SI.Simplify)
Module SI.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_core.MONOID_ARG.SI.Simplify)
Module SI.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/T/Term/index.html b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/T/Term/index.html
index f6f3b62d..2696bc09 100644
--- a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/T/Term/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.MONOID_ARG.SI.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.MONOID_ARG.SI.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/T/Ty/index.html b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/T/Ty/index.html
index f539cc9d..3f9f54c9 100644
--- a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.MONOID_ARG.SI.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.MONOID_ARG.SI.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/index.html b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/index.html
index 5d56df47..4e98b8d7 100644
--- a/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/index.html
@@ -1,2 +1,2 @@
 
-SI (sidekick.Sidekick_core.MONOID_ARG.SI)
Module MONOID_ARG.SI
module T : TERM
module P : PROOF with type term = T.Term.t
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit : LIT with module T = T
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+SI (sidekick.Sidekick_core.MONOID_ARG.SI)
Module MONOID_ARG.SI
module T : TERM
module P : PROOF with type term = T.Term.t
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit : LIT with module T = T
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/CC/index.html
index 305ba936..fbe2ea3c 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_core.SOLVER.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_core.SOLVER.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/Simplify/index.html
index 25fd8fc8..4c4148f1 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_core.SOLVER.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_core.SOLVER.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/index.html
index 78206eec..a59495a4 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_core.SOLVER.Solver_internal)
Module SOLVER.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_core.SOLVER.Solver_internal)
Module SOLVER.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER/T/Term/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER/T/Term/index.html
index aa6b97d9..06b5e05d 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER/T/Term/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.SOLVER.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.SOLVER.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER/T/Ty/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER/T/Ty/index.html
index 156fbbf0..2d157174 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.SOLVER.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.SOLVER.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER/index.html
index 0cdcca56..a8b1884a 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER/index.html
@@ -1,2 +1,2 @@
 
-SOLVER (sidekick.Sidekick_core.SOLVER)
Module type Sidekick_core.SOLVER
User facing view of the solver
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.
module T : TERM
module P : PROOF with type term = T.Term.t
module Lit : LIT with module T = T
module Solver_internal : SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+SOLVER (sidekick.Sidekick_core.SOLVER)
Module type Sidekick_core.SOLVER
User facing view of the solver
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.
module T : TERM
module P : PROOF with type term = T.Term.t
module Lit : LIT with module T = T
module Solver_internal : SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/CC/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/CC/index.html
index 2c7191b9..d4c43f44 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/CC/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_core.SOLVER_INTERNAL.CC)
Module SOLVER_INTERNAL.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_core.SOLVER_INTERNAL.CC)
Module SOLVER_INTERNAL.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/Simplify/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/Simplify/index.html
index edd0e11a..182db6ed 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/Simplify/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_core.SOLVER_INTERNAL.Simplify)
Module SOLVER_INTERNAL.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_core.SOLVER_INTERNAL.Simplify)
Module SOLVER_INTERNAL.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/T/Term/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/T/Term/index.html
index 845400af..be3b5ef5 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/T/Term/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.SOLVER_INTERNAL.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.SOLVER_INTERNAL.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/T/Ty/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/T/Ty/index.html
index f2d588fb..64f22ecb 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.SOLVER_INTERNAL.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.SOLVER_INTERNAL.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/index.html b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/index.html
index f90b57b8..3cfb735c 100644
--- a/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/index.html
@@ -1,2 +1,2 @@
 
-SOLVER_INTERNAL (sidekick.Sidekick_core.SOLVER_INTERNAL)
Module type Sidekick_core.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.
module T : TERM
module P : PROOF with type term = T.Term.t
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit : LIT with module T = T
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+SOLVER_INTERNAL (sidekick.Sidekick_core.SOLVER_INTERNAL)
Module type Sidekick_core.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.
module T : TERM
module P : PROOF with type term = T.Term.t
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit : LIT with module T = T
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_core/module-type-TERM/Term/index.html b/dev/sidekick/Sidekick_core/module-type-TERM/Term/index.html
index 1621961d..03ae57d8 100644
--- a/dev/sidekick/Sidekick_core/module-type-TERM/Term/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-TERM/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.TERM.Term)
Module TERM.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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.Term)
Module TERM.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_core/module-type-TERM/Ty/index.html b/dev/sidekick/Sidekick_core/module-type-TERM/Ty/index.html
index 1c205920..d3b15404 100644
--- a/dev/sidekick/Sidekick_core/module-type-TERM/Ty/index.html
+++ b/dev/sidekick/Sidekick_core/module-type-TERM/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_core.TERM.Ty)
Module TERM.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_core.TERM.Ty)
Module TERM.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Term/index.html b/dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Term/index.html
index 49ca68b4..c5906963 100644
--- a/dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Term/index.html
+++ b/dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_mini_cc.Make.1-A.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_mini_cc.Make.1-A.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Ty/index.html b/dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Ty/index.html
index 20f86cb5..680854fa 100644
--- a/dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_mini_cc/Make/argument-1-A/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_mini_cc.Make.1-A.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_mini_cc.Make.1-A.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_mini_cc/Make/index.html b/dev/sidekick/Sidekick_mini_cc/Make/index.html
index 9c32967e..45b79516 100644
--- a/dev/sidekick/Sidekick_mini_cc/Make/index.html
+++ b/dev/sidekick/Sidekick_mini_cc/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_mini_cc.Make)
Module Sidekick_mini_cc.Make
Instantiate the congruence closure for the given term structure.
Parameters
Signature
type term = A.T.Term.t
type fun_ = A.T.Fun.t
type term_state = A.T.Term.state
type t
An instance of the congruence closure. Mutable
val create : term_state -> t
New instance
val clear : t -> unit
Fully reset the congruence closure's state
val add_lit : t -> term -> 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 -> term 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
+Make (sidekick.Sidekick_mini_cc.Make)
Module Sidekick_mini_cc.Make
Instantiate the congruence closure for the given term structure.
Parameters
Signature
type term = A.T.Term.t
type fun_ = A.T.Fun.t
type term_store = A.T.Term.store
type t
An instance of the congruence closure. Mutable
val create : term_store -> t
New instance
val clear : t -> unit
Fully reset the congruence closure's state
val add_lit : t -> term -> 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 -> term 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
diff --git a/dev/sidekick/Sidekick_mini_cc/index.html b/dev/sidekick/Sidekick_mini_cc/index.html
index 0fc2836a..e8a3d31f 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 CC_view = Sidekick_core.CC_view
module type ARG = sig ... end
Argument for the functor Make
module type S = sig ... end
Main signature for an instance of the mini congruence closure
module Make : functor (A : ARG) -> S with type term = A.T.Term.t and type fun_ = A.T.Fun.t and type term_state = A.T.Term.state
Instantiate the congruence closure for the given term structure.

\ 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 CC_view = Sidekick_core.CC_view
module type ARG = sig ... end
Argument for the functor Make
module type S = sig ... end
Main signature for an instance of the mini congruence closure
module Make : functor (A : ARG) -> S with type term = A.T.Term.t and type fun_ = A.T.Fun.t and type term_store = A.T.Term.store
Instantiate the congruence closure for the given term structure.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Term/index.html b/dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Term/index.html
index 1c4b3f57..b0768032 100644
--- a/dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Term/index.html
+++ b/dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_mini_cc.ARG.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_mini_cc.ARG.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Ty/index.html b/dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Ty/index.html
index e8606a65..f3629ce3 100644
--- a/dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_mini_cc/module-type-ARG/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_mini_cc.ARG.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_mini_cc.ARG.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_mini_cc/module-type-S/index.html b/dev/sidekick/Sidekick_mini_cc/module-type-S/index.html
index 943684ba..b9c97cf4 100644
--- a/dev/sidekick/Sidekick_mini_cc/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_mini_cc/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_mini_cc.S)
Module type Sidekick_mini_cc.S
Main signature for an instance of the mini congruence closure
type term
type fun_
type term_state
type t
An instance of the congruence closure. Mutable
val create : term_state -> t
New instance
val clear : t -> unit
Fully reset the congruence closure's state
val add_lit : t -> term -> 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 -> term 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
+S (sidekick.Sidekick_mini_cc.S)
Module type Sidekick_mini_cc.S
Main signature for an instance of the mini congruence closure
type term
type fun_
type term_store
type t
An instance of the congruence closure. Mutable
val create : term_store -> t
New instance
val clear : t -> unit
Fully reset the congruence closure's state
val add_lit : t -> term -> 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 -> term 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
diff --git a/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/CC/index.html
index e1778afc..d779990e 100644
--- a/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_msat_solver.Make.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_msat_solver.Make.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/Simplify/index.html
index 1b0bb915..8de64ea4 100644
--- a/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_msat_solver.Make.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_msat_solver.Make.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/index.html b/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/index.html
index 2948f6bb..4718c956 100644
--- a/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/Make/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_msat_solver.Make.Solver_internal)
Module Make.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_msat_solver.Make.Solver_internal)
Module Make.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/Make/argument-1-A/T/Term/index.html b/dev/sidekick/Sidekick_msat_solver/Make/argument-1-A/T/Term/index.html
index ac665f03..3e2bb61b 100644
--- a/dev/sidekick/Sidekick_msat_solver/Make/argument-1-A/T/Term/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/Make/argument-1-A/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_msat_solver.Make.1-A.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_msat_solver.Make.1-A.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_msat_solver/Make/argument-1-A/T/Ty/index.html b/dev/sidekick/Sidekick_msat_solver/Make/argument-1-A/T/Ty/index.html
index 5d53bf13..a991dfb5 100644
--- a/dev/sidekick/Sidekick_msat_solver/Make/argument-1-A/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/Make/argument-1-A/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_msat_solver.Make.1-A.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_msat_solver.Make.1-A.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/Make/index.html b/dev/sidekick/Sidekick_msat_solver/Make/index.html
index 12e13e19..1522f764 100644
--- a/dev/sidekick/Sidekick_msat_solver/Make/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_msat_solver.Make)
Module Sidekick_msat_solver.Make
Main functor to get a solver.
Parameters
Signature
module T = A.T
module P = A.P
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+Make (sidekick.Sidekick_msat_solver.Make)
Module Sidekick_msat_solver.Make
Main functor to get a solver.
Parameters
Signature
module T = A.T
module P = A.P
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/module-type-ARG/T/Term/index.html b/dev/sidekick/Sidekick_msat_solver/module-type-ARG/T/Term/index.html
index 0112d055..037b36be 100644
--- a/dev/sidekick/Sidekick_msat_solver/module-type-ARG/T/Term/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/module-type-ARG/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_msat_solver.ARG.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_msat_solver.ARG.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_msat_solver/module-type-ARG/T/Ty/index.html b/dev/sidekick/Sidekick_msat_solver/module-type-ARG/T/Ty/index.html
index a23431cf..5520b194 100644
--- a/dev/sidekick/Sidekick_msat_solver/module-type-ARG/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/module-type-ARG/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_msat_solver.ARG.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_msat_solver.ARG.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/CC/index.html
index 61613902..3e7939ad 100644
--- a/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_msat_solver.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_msat_solver.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/Simplify/index.html
index 60d7f84c..283c5bdc 100644
--- a/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_msat_solver.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_msat_solver.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/index.html b/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/index.html
index 40dd02c3..a1ae7c7c 100644
--- a/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/module-type-S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_msat_solver.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_msat_solver.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/module-type-S/T/Term/index.html b/dev/sidekick/Sidekick_msat_solver/module-type-S/T/Term/index.html
index 4e9eeeab..b33a9a4a 100644
--- a/dev/sidekick/Sidekick_msat_solver/module-type-S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/module-type-S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_msat_solver.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_msat_solver.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_msat_solver/module-type-S/T/Ty/index.html b/dev/sidekick/Sidekick_msat_solver/module-type-S/T/Ty/index.html
index d1fa09b7..e3998928 100644
--- a/dev/sidekick/Sidekick_msat_solver/module-type-S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/module-type-S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_msat_solver.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_msat_solver.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_msat_solver/module-type-S/index.html b/dev/sidekick/Sidekick_msat_solver/module-type-S/index.html
index 2e429eea..46ab1019 100644
--- a/dev/sidekick/Sidekick_msat_solver/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_msat_solver/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_msat_solver.S)
Module type Sidekick_msat_solver.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_msat_solver.S)
Module type Sidekick_msat_solver.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/Gensym/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/Gensym/index.html
index 565722d1..9e886b8e 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/Gensym/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/Gensym/index.html
@@ -1,2 +1,2 @@
 
-Gensym (sidekick.Sidekick_th_bool_static.Make.1-A.Gensym)
Module 1-A.Gensym
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.
type t
val create : S.T.Term.state -> t
New (stateful) generator instance.
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
+Gensym (sidekick.Sidekick_th_bool_static.Make.1-A.Gensym)
Module 1-A.Gensym
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.
type t
val create : S.T.Term.store -> t
New (stateful) generator instance.
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/CC/index.html
index 9285c49a..74e8346e 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_bool_static.Make.1-A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_bool_static.Make.1-A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/Simplify/index.html
index 630d98d8..822992a7 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_bool_static.Make.1-A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_bool_static.Make.1-A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/index.html
index 20f84c72..883e141a 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_bool_static.Make.1-A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_bool_static.Make.1-A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/T/Term/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/T/Term/index.html
index 014b0775..a138d861 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_bool_static.Make.1-A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_bool_static.Make.1-A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/T/Ty/index.html
index e62f3868..e0f2e9f2 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_bool_static.Make.1-A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_bool_static.Make.1-A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/index.html
index 9887cac4..a51defcd 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_bool_static.Make.1-A.S)
Module 1-A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_bool_static.Make.1-A.S)
Module 1-A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/index.html
index ee1868b4..9c4ef1c8 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/index.html
@@ -1,2 +1,2 @@
 
-1-A (sidekick.Sidekick_th_bool_static.Make.1-A)
Parameter Make.1-A
type term = S.T.Term.t
val view_as_bool : term -> (term, term Iter.t) bool_view
Project the term into the boolean view.
val proof_ite_true : S.T.Term.t -> S.P.t
proof_ite_true (ite a b c) is a=true |- ite a b c = b
val proof_ite_false : S.T.Term.t -> S.P.t
proof_ite_false (ite a b c) is a=false |- ite a b c = c
val proof_bool_eq : S.T.Term.t -> S.T.Term.t -> S.P.t
Basic boolean logic for |- a=b
val proof_bool_c : string -> term list -> S.P.t
Basic boolean logic for a clause |- c
val mk_bool : S.T.Term.state -> (term, term Sidekick_util.IArray.t) bool_view -> term
Make a term from the given boolean view.
val check_congruence_classes : bool
Configuration: add final-check handler to verify if new boolean formulas are present in the congruence closure. Only enable if some theories are susceptible to create boolean formulas during the proof search.
module Gensym : sig ... end
Fresh symbol generator.

\ No newline at end of file
+1-A (sidekick.Sidekick_th_bool_static.Make.1-A)
Parameter Make.1-A
type term = S.T.Term.t
val view_as_bool : term -> (term, term Iter.t) bool_view
Project the term into the boolean view.
val proof_ite_true : S.T.Term.t -> S.P.t
proof_ite_true (ite a b c) is a=true |- ite a b c = b
val proof_ite_false : S.T.Term.t -> S.P.t
proof_ite_false (ite a b c) is a=false |- ite a b c = c
val proof_bool_eq : S.T.Term.t -> S.T.Term.t -> S.P.t
Basic boolean logic for |- a=b
val proof_bool_c : string -> term list -> S.P.t
Basic boolean logic for a clause |- c
val mk_bool : S.T.Term.store -> (term, term Sidekick_util.IArray.t) bool_view -> term
Make a term from the given boolean view.
val check_congruence_classes : bool
Configuration: add final-check handler to verify if new boolean formulas are present in the congruence closure. Only enable if some theories are susceptible to create boolean formulas during the proof search.
module Gensym : sig ... end
Fresh symbol generator.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/Make/index.html b/dev/sidekick/Sidekick_th_bool_static/Make/index.html
index 81e7019e..5194a8db 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Make/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_th_bool_static.Make)
Module Sidekick_th_bool_static.Make
Parameters
Signature
module A = A
type state
val create : A.S.T.Term.state -> A.S.T.Ty.state -> state
val simplify : state -> A.S.Solver_internal.simplify_hook
Simplify given term
val cnf : state -> A.S.Solver_internal.preprocess_hook
preprocesses formulas by giving them names and adding clauses to equate the name with the boolean formula.
val theory : A.S.theory
A theory that can be added to the solver A.S.
This theory does most of its work during preprocessing, turning boolean formulas into SAT clauses via the Tseitin encoding .

\ No newline at end of file
+Make (sidekick.Sidekick_th_bool_static.Make)
Module Sidekick_th_bool_static.Make
Parameters
Signature
module A = A
type state
val create : A.S.T.Term.store -> A.S.T.Ty.store -> state
val simplify : state -> A.S.Solver_internal.simplify_hook
Simplify given term
val cnf : state -> A.S.Solver_internal.preprocess_hook
preprocesses formulas by giving them names and adding clauses to equate the name with the boolean formula.
val theory : A.S.theory
A theory that can be added to the solver A.S.
This theory does most of its work during preprocessing, turning boolean formulas into SAT clauses via the Tseitin encoding .

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/Gensym/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/Gensym/index.html
index d263511f..cfe560e2 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/Gensym/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/Gensym/index.html
@@ -1,2 +1,2 @@
 
-Gensym (sidekick.Sidekick_th_bool_static.ARG.Gensym)
Module ARG.Gensym
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.
type t
val create : S.T.Term.state -> t
New (stateful) generator instance.
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
+Gensym (sidekick.Sidekick_th_bool_static.ARG.Gensym)
Module ARG.Gensym
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.
type t
val create : S.T.Term.store -> t
New (stateful) generator instance.
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/CC/index.html
index 30d9510d..8fb07d44 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_bool_static.ARG.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_bool_static.ARG.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/Simplify/index.html
index 93d2a3da..d6c3b4f3 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_bool_static.ARG.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_bool_static.ARG.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/index.html
index 1464915f..e37758f9 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_bool_static.ARG.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_bool_static.ARG.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/T/Term/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/T/Term/index.html
index 0dbeb122..96d0c7a0 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_bool_static.ARG.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_bool_static.ARG.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/T/Ty/index.html
index 76177a69..88c23f2a 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_bool_static.ARG.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_bool_static.ARG.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/index.html
index 72267e09..811d137b 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_bool_static.ARG.S)
Module ARG.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_bool_static.ARG.S)
Module ARG.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/index.html
index 72f732d6..441d2cab 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_th_bool_static.ARG)
Module type Sidekick_th_bool_static.ARG
Argument to the theory
type term = S.T.Term.t
val view_as_bool : term -> (term, term Iter.t) bool_view
Project the term into the boolean view.
val proof_ite_true : S.T.Term.t -> S.P.t
proof_ite_true (ite a b c) is a=true |- ite a b c = b
val proof_ite_false : S.T.Term.t -> S.P.t
proof_ite_false (ite a b c) is a=false |- ite a b c = c
val proof_bool_eq : S.T.Term.t -> S.T.Term.t -> S.P.t
Basic boolean logic for |- a=b
val proof_bool_c : string -> term list -> S.P.t
Basic boolean logic for a clause |- c
val mk_bool : S.T.Term.state -> (term, term Sidekick_util.IArray.t) bool_view -> term
Make a term from the given boolean view.
val check_congruence_classes : bool
Configuration: add final-check handler to verify if new boolean formulas are present in the congruence closure. Only enable if some theories are susceptible to create boolean formulas during the proof search.
module Gensym : sig ... end
Fresh symbol generator.

\ No newline at end of file
+ARG (sidekick.Sidekick_th_bool_static.ARG)
Module type Sidekick_th_bool_static.ARG
Argument to the theory
type term = S.T.Term.t
val view_as_bool : term -> (term, term Iter.t) bool_view
Project the term into the boolean view.
val proof_ite_true : S.T.Term.t -> S.P.t
proof_ite_true (ite a b c) is a=true |- ite a b c = b
val proof_ite_false : S.T.Term.t -> S.P.t
proof_ite_false (ite a b c) is a=false |- ite a b c = c
val proof_bool_eq : S.T.Term.t -> S.T.Term.t -> S.P.t
Basic boolean logic for |- a=b
val proof_bool_c : string -> term list -> S.P.t
Basic boolean logic for a clause |- c
val mk_bool : S.T.Term.store -> (term, term Sidekick_util.IArray.t) bool_view -> term
Make a term from the given boolean view.
val check_congruence_classes : bool
Configuration: add final-check handler to verify if new boolean formulas are present in the congruence closure. Only enable if some theories are susceptible to create boolean formulas during the proof search.
module Gensym : sig ... end
Fresh symbol generator.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/Gensym/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/Gensym/index.html
index ec791035..c12e890d 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/Gensym/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/Gensym/index.html
@@ -1,2 +1,2 @@
 
-Gensym (sidekick.Sidekick_th_bool_static.S.A.Gensym)
Module A.Gensym
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.
type t
val create : S.T.Term.state -> t
New (stateful) generator instance.
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
+Gensym (sidekick.Sidekick_th_bool_static.S.A.Gensym)
Module A.Gensym
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.
type t
val create : S.T.Term.store -> t
New (stateful) generator instance.
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
Make a fresh term of the given type

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/CC/index.html
index b3779fcb..8cd877f6 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_bool_static.S.A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_bool_static.S.A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/Simplify/index.html
index eb51c5ea..dd222249 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_bool_static.S.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_bool_static.S.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/index.html
index aec52a35..4fd5c077 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_bool_static.S.A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_bool_static.S.A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/T/Term/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/T/Term/index.html
index a4ceb86c..a1df9c29 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_bool_static.S.A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_bool_static.S.A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/T/Ty/index.html
index eeb361f4..ae16f7af 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_bool_static.S.A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_bool_static.S.A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/index.html
index c28ea0b2..3f356a03 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_bool_static.S.A.S)
Module A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_bool_static.S.A.S)
Module A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/index.html
index 24a1302b..5c0d1e99 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/A/index.html
@@ -1,2 +1,2 @@
 
-A (sidekick.Sidekick_th_bool_static.S.A)
Module S.A
type term = S.T.Term.t
val view_as_bool : term -> (term, term Iter.t) bool_view
Project the term into the boolean view.
val proof_ite_true : S.T.Term.t -> S.P.t
proof_ite_true (ite a b c) is a=true |- ite a b c = b
val proof_ite_false : S.T.Term.t -> S.P.t
proof_ite_false (ite a b c) is a=false |- ite a b c = c
val proof_bool_eq : S.T.Term.t -> S.T.Term.t -> S.P.t
Basic boolean logic for |- a=b
val proof_bool_c : string -> term list -> S.P.t
Basic boolean logic for a clause |- c
val mk_bool : S.T.Term.state -> (term, term Sidekick_util.IArray.t) bool_view -> term
Make a term from the given boolean view.
val check_congruence_classes : bool
Configuration: add final-check handler to verify if new boolean formulas are present in the congruence closure. Only enable if some theories are susceptible to create boolean formulas during the proof search.
module Gensym : sig ... end
Fresh symbol generator.

\ No newline at end of file
+A (sidekick.Sidekick_th_bool_static.S.A)
Module S.A
type term = S.T.Term.t
val view_as_bool : term -> (term, term Iter.t) bool_view
Project the term into the boolean view.
val proof_ite_true : S.T.Term.t -> S.P.t
proof_ite_true (ite a b c) is a=true |- ite a b c = b
val proof_ite_false : S.T.Term.t -> S.P.t
proof_ite_false (ite a b c) is a=false |- ite a b c = c
val proof_bool_eq : S.T.Term.t -> S.T.Term.t -> S.P.t
Basic boolean logic for |- a=b
val proof_bool_c : string -> term list -> S.P.t
Basic boolean logic for a clause |- c
val mk_bool : S.T.Term.store -> (term, term Sidekick_util.IArray.t) bool_view -> term
Make a term from the given boolean view.
val check_congruence_classes : bool
Configuration: add final-check handler to verify if new boolean formulas are present in the congruence closure. Only enable if some theories are susceptible to create boolean formulas during the proof search.
module Gensym : sig ... end
Fresh symbol generator.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_bool_static/module-type-S/index.html b/dev/sidekick/Sidekick_th_bool_static/module-type-S/index.html
index 553cebed..cc84922e 100644
--- a/dev/sidekick/Sidekick_th_bool_static/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_bool_static.S)
Module type Sidekick_th_bool_static.S
Signature
module A : ARG
type state
val create : A.S.T.Term.state -> A.S.T.Ty.state -> state
val simplify : state -> A.S.Solver_internal.simplify_hook
Simplify given term
val cnf : state -> A.S.Solver_internal.preprocess_hook
preprocesses formulas by giving them names and adding clauses to equate the name with the boolean formula.
val theory : A.S.theory
A theory that can be added to the solver A.S.
This theory does most of its work during preprocessing, turning boolean formulas into SAT clauses via the Tseitin encoding .

\ No newline at end of file
+S (sidekick.Sidekick_th_bool_static.S)
Module type Sidekick_th_bool_static.S
Signature
module A : ARG
type state
val create : A.S.T.Term.store -> A.S.T.Ty.store -> state
val simplify : state -> A.S.Solver_internal.simplify_hook
Simplify given term
val cnf : state -> A.S.Solver_internal.preprocess_hook
preprocesses formulas by giving them names and adding clauses to equate the name with the boolean formula.
val theory : A.S.theory
A theory that can be added to the solver A.S.
This theory does most of its work during preprocessing, turning boolean formulas into SAT clauses via the Tseitin encoding .

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/CC/index.html
index 113f8001..3bbf3667 100644
--- a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_cstor.Make.1-A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_cstor.Make.1-A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/Simplify/index.html
index d840c7f1..eb6543cd 100644
--- a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_cstor.Make.1-A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_cstor.Make.1-A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/index.html
index c5647246..50aedd70 100644
--- a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_cstor.Make.1-A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_cstor.Make.1-A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/T/Term/index.html b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/T/Term/index.html
index 7152b470..a3715e45 100644
--- a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_cstor.Make.1-A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_cstor.Make.1-A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/T/Ty/index.html
index f462779e..58f54adb 100644
--- a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_cstor.Make.1-A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_cstor.Make.1-A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/index.html b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/index.html
index 41894b85..615b9cca 100644
--- a/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_cstor.Make.1-A.S)
Module 1-A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_cstor.Make.1-A.S)
Module 1-A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/CC/index.html
index 2ee6a0ee..4c7c7ff2 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_cstor.ARG.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_cstor.ARG.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/Simplify/index.html
index 85a55590..03bff13a 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_cstor.ARG.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_cstor.ARG.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/index.html
index 96b30247..574911c9 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_cstor.ARG.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_cstor.ARG.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/T/Term/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/T/Term/index.html
index e3161201..5dcbf080 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_cstor.ARG.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_cstor.ARG.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/T/Ty/index.html
index e862fd3d..be1b4fcd 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_cstor.ARG.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_cstor.ARG.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/index.html
index 688114b3..bf87d45d 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_cstor.ARG.S)
Module ARG.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_cstor.ARG.S)
Module ARG.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/CC/index.html
index da9769b7..161f2850 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_cstor.S.A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_cstor.S.A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/Simplify/index.html
index a189b28f..9c0fdf2a 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_cstor.S.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_cstor.S.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/index.html
index eedd8242..adae2d9f 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_cstor.S.A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_cstor.S.A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/T/Term/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/T/Term/index.html
index 29c6de86..2ae4fc41 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_cstor.S.A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_cstor.S.A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/T/Ty/index.html
index 82996f2a..bd9b9dba 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_cstor.S.A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_cstor.S.A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/index.html
index cea013c0..7149203e 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_cstor.S.A.S)
Module A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_cstor.S.A.S)
Module A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/CC/index.html
index a7be1c3a..1d76f654 100644
--- a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_data.Make.1-A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_data.Make.1-A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/Simplify/index.html
index f90c1606..5ec05658 100644
--- a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_data.Make.1-A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_data.Make.1-A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/index.html
index ed122cfa..ce261cfa 100644
--- a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_data.Make.1-A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_data.Make.1-A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/T/Term/index.html b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/T/Term/index.html
index bb667af7..4416c1c2 100644
--- a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_data.Make.1-A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_data.Make.1-A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/T/Ty/index.html
index 0f8fa41f..dd1a6748 100644
--- a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_data.Make.1-A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_data.Make.1-A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/index.html b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/index.html
index b319450c..3ee103ce 100644
--- a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/index.html
+++ b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_data.Make.1-A.S)
Module 1-A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_data.Make.1-A.S)
Module 1-A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/index.html b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/index.html
index 1df4f206..a80c8818 100644
--- a/dev/sidekick/Sidekick_th_data/Make/argument-1-A/index.html
+++ b/dev/sidekick/Sidekick_th_data/Make/argument-1-A/index.html
@@ -1,2 +1,2 @@
 
-1-A (sidekick.Sidekick_th_data.Make.1-A)
Parameter Make.1-A
module Cstor : sig ... end
Constructor symbols.
val as_datatype : S.T.Ty.t -> (Cstor.t Iter.t, S.T.Ty.t) data_ty_view
Try to view type as a datatype (with its constructors)
val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) data_view
Try to view term as a datatype term
val mk_cstor : S.T.Term.state -> Cstor.t -> S.T.Term.t Sidekick_util.IArray.t -> S.T.Term.t
Make a constructor application term
val mk_is_a : S.T.Term.state -> Cstor.t -> S.T.Term.t -> S.T.Term.t
Make a is-a term
val mk_sel : S.T.Term.state -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
Make a selector term
val mk_eq : S.T.Term.state -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
Make a term equality
val ty_is_finite : S.T.Ty.t -> 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 : S.T.Ty.t -> bool -> unit
Modify the "finite" field (see ty_is_finite)
val proof_isa_split : S.T.Ty.t -> S.T.Term.t Iter.t -> S.P.t
val proof_isa_disj : S.T.Ty.t -> S.T.Term.t -> S.T.Term.t -> S.P.t
val proof_cstor_inj : Cstor.t -> int -> S.T.Term.t list -> S.T.Term.t list -> S.P.t

\ No newline at end of file
+1-A (sidekick.Sidekick_th_data.Make.1-A)
Parameter Make.1-A
module Cstor : sig ... end
Constructor symbols.
val as_datatype : S.T.Ty.t -> (Cstor.t Iter.t, S.T.Ty.t) data_ty_view
Try to view type as a datatype (with its constructors)
val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) data_view
Try to view term as a datatype term
val mk_cstor : S.T.Term.store -> Cstor.t -> S.T.Term.t Sidekick_util.IArray.t -> S.T.Term.t
Make a constructor application term
val mk_is_a : S.T.Term.store -> Cstor.t -> S.T.Term.t -> S.T.Term.t
Make a is-a term
val mk_sel : S.T.Term.store -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
Make a selector term
val mk_eq : S.T.Term.store -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
Make a term equality
val ty_is_finite : S.T.Ty.t -> 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 : S.T.Ty.t -> bool -> unit
Modify the "finite" field (see ty_is_finite)
val proof_isa_split : S.T.Ty.t -> S.T.Term.t Iter.t -> S.P.t
val proof_isa_disj : S.T.Ty.t -> S.T.Term.t -> S.T.Term.t -> S.P.t
val proof_cstor_inj : Cstor.t -> int -> S.T.Term.t list -> S.T.Term.t list -> S.P.t

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/CC/index.html
index 6a1f6d61..530ffa57 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_data.ARG.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_data.ARG.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/Simplify/index.html
index abde52f3..010e3b4e 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_data.ARG.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_data.ARG.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/index.html
index d6def99f..799361ff 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_data.ARG.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_data.ARG.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Term/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Term/index.html
index 8aa3f8a1..9664b270 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_data.ARG.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_data.ARG.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Ty/index.html
index e4c670eb..fc5382a2 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_data.ARG.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_data.ARG.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/index.html
index 0183c744..362f7f84 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/S/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_data.ARG.S)
Module ARG.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_data.ARG.S)
Module ARG.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
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 67eaa662..e79cf444 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_th_data.ARG)
Module type Sidekick_th_data.ARG
Argument to the functor
module Cstor : sig ... end
Constructor symbols.
val as_datatype : S.T.Ty.t -> (Cstor.t Iter.t, S.T.Ty.t) data_ty_view
Try to view type as a datatype (with its constructors)
val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) data_view
Try to view term as a datatype term
val mk_cstor : S.T.Term.state -> Cstor.t -> S.T.Term.t Sidekick_util.IArray.t -> S.T.Term.t
Make a constructor application term
val mk_is_a : S.T.Term.state -> Cstor.t -> S.T.Term.t -> S.T.Term.t
Make a is-a term
val mk_sel : S.T.Term.state -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
Make a selector term
val mk_eq : S.T.Term.state -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
Make a term equality
val ty_is_finite : S.T.Ty.t -> 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 : S.T.Ty.t -> bool -> unit
Modify the "finite" field (see ty_is_finite)
val proof_isa_split : S.T.Ty.t -> S.T.Term.t Iter.t -> S.P.t
val proof_isa_disj : S.T.Ty.t -> S.T.Term.t -> S.T.Term.t -> S.P.t
val proof_cstor_inj : Cstor.t -> int -> S.T.Term.t list -> S.T.Term.t list -> S.P.t

\ No newline at end of file
+ARG (sidekick.Sidekick_th_data.ARG)
Module type Sidekick_th_data.ARG
Argument to the functor
module Cstor : sig ... end
Constructor symbols.
val as_datatype : S.T.Ty.t -> (Cstor.t Iter.t, S.T.Ty.t) data_ty_view
Try to view type as a datatype (with its constructors)
val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) data_view
Try to view term as a datatype term
val mk_cstor : S.T.Term.store -> Cstor.t -> S.T.Term.t Sidekick_util.IArray.t -> S.T.Term.t
Make a constructor application term
val mk_is_a : S.T.Term.store -> Cstor.t -> S.T.Term.t -> S.T.Term.t
Make a is-a term
val mk_sel : S.T.Term.store -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
Make a selector term
val mk_eq : S.T.Term.store -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
Make a term equality
val ty_is_finite : S.T.Ty.t -> 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 : S.T.Ty.t -> bool -> unit
Modify the "finite" field (see ty_is_finite)
val proof_isa_split : S.T.Ty.t -> S.T.Term.t Iter.t -> S.P.t
val proof_isa_disj : S.T.Ty.t -> S.T.Term.t -> S.T.Term.t -> S.P.t
val proof_cstor_inj : Cstor.t -> int -> S.T.Term.t list -> S.T.Term.t list -> S.P.t

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/CC/index.html
index 6e5b373f..89ef14b6 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/CC/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/CC/index.html
@@ -1,2 +1,2 @@
 
-CC (sidekick.Sidekick_th_data.S.A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_state = T.Term.state
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_state : t -> term_state
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_state -> t
Create a new congruence closure.
parameter term_state
used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.
val allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
+CC (sidekick.Sidekick_th_data.S.A.S.Solver_internal.CC)
Module Solver_internal.CC
Congruence closure instance
module T = T
module P = P
module Lit = Lit
module Actions : Sidekick_core.CC_ACTIONS with module T = T and module Lit = Lit and module P = P and type t = actions
type term_store = T.Term.store
type term = T.Term.t
type fun_ = T.Fun.t
type lit = Lit.t
type proof = P.t
type actions = Actions.t
type t
State of the congruence closure
module N : sig ... end
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".
module Expl : sig ... end
Explanations
type node = N.t
A node of the congruence closure
type repr = N.t
Node that is currently a representative
type explanation = Expl.t
Accessors
val term_store : t -> term_store
val find : t -> node -> repr
Current representative
val add_term : t -> term -> node
Add the term to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> term -> bool
Returns true if the term is explicitly present in the congruence closure
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.
type ev_on_new_term = t -> N.t -> term -> unit
ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.
type ev_on_conflict = t -> th:bool -> lit list -> unit
ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.
parameter th
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.
type ev_on_propagate = t -> lit -> (unit -> lit list * P.t) -> unit
ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See Sidekick_core.CC_ACTIONS.propagate.
type ev_on_is_subterm = N.t -> term -> unit
ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠on_pre_merge:ev_on_pre_merge list -> ?⁠on_post_merge:ev_on_post_merge list -> ?⁠on_new_term:ev_on_new_term list -> ?⁠on_conflict:ev_on_conflict list -> ?⁠on_propagate:ev_on_propagate list -> ?⁠on_is_subterm:ev_on_is_subterm list -> ?⁠size:[ `Small | `Big ] -> term_store -> 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 allocate_bitfield : descr:string -> t -> N.bitfield
Allocate a new bitfield for the nodes. See N.bitfield.
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
Set the bitfield for the node. This will be backtracked. See N.bitfield.
val on_pre_merge : t -> ev_on_pre_merge -> unit
Add a function to be called when two classes are merged
val on_post_merge : t -> ev_on_post_merge -> unit
Add a function to be called when two classes are merged
val on_new_term : t -> ev_on_new_term -> unit
Add a function to be called when a new node is created
val on_conflict : t -> ev_on_conflict -> unit
Called when the congruence closure finds a conflict
val on_propagate : t -> ev_on_propagate -> unit
Called when the congruence closure propagates a literal
val on_is_subterm : t -> ev_on_is_subterm -> unit
Called on terms that are subterms of function symbols
val set_as_lit : t -> N.t -> lit -> unit
map the given node to a literal.
val find_t : t -> term -> repr
Current representative of the term.
raises Not_found
if the term is not already add-ed.
val add_seq : t -> term 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 assert_lit : t -> lit -> unit
Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.
Useful for the theory combination or the SAT solver's functor
val assert_lits : t -> lit Iter.t -> unit
Addition of many literals
val explain_eq : t -> N.t -> N.t -> lit list
Explain why the two nodes are equal. Fails if they are not, in an unspecified way
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
Raise a conflict with the given explanation it must be a theory tautology that expl ==> absurd. To be used in theories.
val n_true : t -> N.t
Node for true
val n_false : t -> N.t
Node for false
val n_bool : t -> bool -> N.t
Node for either true or false
val merge : t -> N.t -> N.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 -> term -> term -> Expl.t -> unit
Shortcut for adding + merging
val check : t -> actions -> unit
Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.
val new_merges : t -> bool
Called after check, returns true if some pairs of classes were merged.
val push_level : t -> unit
Push backtracking level
val pop_levels : t -> int -> unit
Restore to state n calls to push_level earlier. Used during backtracking.
val get_model : t -> N.t Iter.t Iter.t
get all the equivalence classes so they can be merged in the model

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/Simplify/index.html
index 097b5b96..c811a377 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/Simplify/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/Simplify/index.html
@@ -1,2 +1,2 @@
 
-Simplify (sidekick.Sidekick_th_data.S.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_state
val ty_st : t -> ty_state
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
+Simplify (sidekick.Sidekick_th_data.S.A.S.Solver_internal.Simplify)
Module Solver_internal.Simplify
Simplify terms
type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
Reset internal cache, etc.
type hook = t -> term -> (term * proof) option
Given a term, try to simplify it. Return None if it didn't change.
A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.
val normalize : t -> term -> (term * P.t) option
Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.
val normalize_t : t -> term -> term * P.t
Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, refl t if no simplification occurred.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/index.html
index 83c0640f..9b65192b 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/Solver_internal/index.html
@@ -1,2 +1,2 @@
 
-Solver_internal (sidekick.Sidekick_th_data.S.A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_state = T.Term.state
type ty_state = T.Ty.state
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_state
val ty_st : t -> ty_state
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
+Solver_internal (sidekick.Sidekick_th_data.S.A.S.Solver_internal)
Module S.Solver_internal
Internal solver, available to theories.
module T = T
module P = P
type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = P.t
type t
Main type for a solver
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
Actions for the theories
type actions
Handle that the theories can use to perform actions.
module Lit = Lit
type lit = Lit.t
Proof helpers
val define_const : t -> const:term -> rhs:term -> unit
define_const si ~const ~rhs adds the definition const := rhs to the (future) proof. const should be a fresh constant that occurs nowhere else, and rhs a term defined without const.
Congruence Closure
module CC : Sidekick_core.CC_S with module T = T and module P = P and module Lit = Lit and type Actions.t = actions
Congruence closure instance
val cc : t -> CC.t
Congruence closure for this solver
Simplifiers
module Simplify : sig ... end
Simplify terms
type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit
Add a simplifier hook for preprocessing.
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> (term * proof) option
Simplify input term, returns Some (u, |- t=u) if some simplification occurred.
val simp_t : t -> term -> term * proof
simp_t si t returns u, |- t=u even if no simplification occurred (in which case t == u syntactically). (see simplifier)
hooks for the theory
val raise_conflict : t -> actions -> lit list -> proof -> 'a
Give a conflict clause to the solver
val push_decision : t -> actions -> lit -> unit
Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.
val propagate : t -> actions -> lit -> reason:(unit -> lit list * proof) -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val propagate_l : t -> actions -> lit -> lit list -> proof -> unit
Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology
val add_clause_temp : t -> actions -> lit list -> proof -> unit
Add local clause to the SAT solver. This clause will be removed when the solver backtracks.
val add_clause_permanent : t -> actions -> lit list -> proof -> unit
Add toplevel clause to the SAT solver. This clause will not be backtracked.
val mk_lit : t -> actions -> ?⁠sign:bool -> term -> lit
Create a literal. This automatically preprocesses the term.
val preprocess_term : t -> add_clause:(Lit.t list -> proof -> unit) -> term -> term * proof
Preprocess a term.
val add_lit : t -> actions -> lit -> unit
Add the given literal to the SAT solver, so it gets assigned a boolean value
val add_lit_t : t -> actions -> ?⁠sign:bool -> term -> unit
Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value
val cc_raise_conflict_expl : t -> actions -> CC.Expl.t -> 'a
Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.
val cc_find : t -> CC.N.t -> CC.N.t
Find representative of the node
val cc_are_equal : t -> term -> term -> bool
Are these two terms equal in the congruence closure?
val cc_merge : t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.
val cc_merge_t : t -> actions -> term -> term -> CC.Expl.t -> unit
Merge these two terms in the congruence closure, given this explanation. See cc_merge
val cc_add_term : t -> term -> CC.N.t
Add/retrieve congruence closure node for this term. To be used in theories
val cc_mem_term : t -> term -> bool
Return true if the term is explicitly in the congruence closure. To be used in theories
val on_cc_pre_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called before)
val on_cc_post_merge : t -> (CC.t -> actions -> CC.N.t -> CC.N.t -> unit) -> unit
Callback for when two classes containing data for this key are merged (called after)
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
Callback to add data on terms when they are added to the congruence closure
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
Callback for when a term is a subterm of another term in the congruence closure
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
Callback called on every CC conflict
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * proof) -> unit) -> unit
Callback called on every CC propagation
val on_partial_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callbacked to be called with the slice of literals newly added on the trail.
This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.
val on_final_check : t -> (t -> actions -> lit Iter.t -> unit) -> unit
Register callback to be called during the final check.
Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.
Preprocessors
These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.
type preprocess_hook = t -> mk_lit:(term -> lit) -> add_clause:(lit list -> proof -> unit) -> term -> (term * proof) option
Given a term, try to preprocess it. Return None if it didn't change, or Some (u,p) if t=u and p is a proof of t=u. Can also add clauses to define new terms.
Preprocessing might transform terms to make them more amenable to reasoning, e.g. by removing boolean formulas via Tseitin encoding, adding clauses that encode their meaning in the same move.
parameter mk_lit
creates a new literal for a boolean term.
parameter add_clause
pushes a new clause into the SAT solver.
val on_preprocess : t -> preprocess_hook -> unit
Add a hook that will be called when terms are preprocessed
Model production
type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option
A model-production hook. It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.
If no hook assigns a value to a class, a fake value is created for it.
val on_model_gen : t -> model_hook -> unit
Add a hook that will be called when a model is being produced

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Term/index.html b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Term/index.html
index cc05a1a3..36d9ff97 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Term/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_th_data.S.A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
A state used to create new terms. It is where the hashconsing table should live, along with other all-terms related state.
val ty : t -> Ty.t
val bool : state -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : state -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The state is passed in case a new term needs to be created.
val map_shallow : state -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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_th_data.S.A.S.T.Term)
Module T.Term
Term structure.
Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.
type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.
val ty : t -> Ty.t
val bool : store -> bool -> t
build true/false
val as_bool : t -> bool option
as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.
val abs : store -> t -> t * bool
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 (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).
The store is passed in case a new term needs to be created.
val map_shallow : store -> (t -> t) -> t -> t
Map function on immediate subterms. This should not be recursive.
val iter_dag : t -> (t -> unit) -> 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
diff --git a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Ty/index.html b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Ty/index.html
index da6e68ff..1ef70f0a 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Ty/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/T/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_th_data.S.A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type state
val bool : state -> t
val is_bool : t -> bool

\ No newline at end of file
+Ty (sidekick.Sidekick_th_data.S.A.S.T.Ty)
Module T.Ty
Types
Types should be comparable (ideally, in O(1)), and have at least a boolean type available.
type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/index.html b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/index.html
index 8030cd2c..386007b2 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-S/A/S/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-S/A/S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_th_data.S.A.S)
Module A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.state
val ty_st : t -> T.Ty.state
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.state -> T.Ty.state -> 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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
+S (sidekick.Sidekick_th_data.S.A.S)
Module A.S
module P : Sidekick_core.PROOF with type term = T.Term.t
module Lit : Sidekick_core.LIT with module T = T
module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module P = P and module Lit = Lit
Internal solver, available to theories.
type t
The solver's state.
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type proof = P.t
module type THEORY = sig ... end
type theory = (module THEORY)
A theory that can be used for this particular solver.
type 'a theory_p = (module THEORY with type t = 'a)
A theory that can be used for this particular solver, with state of type 'a.
val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory
Helper to create a theory.
module Atom : sig ... end
module Model : sig ... end
Models
module Unknown : sig ... end
Main API
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> ?⁠store_proof:bool -> theories:theory list -> T.Term.store -> T.Ty.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 -> theory -> 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 list -> unit
val mk_atom_lit : t -> lit -> Atom.t * P.t
mk_atom_lit _ lit returns atom, pr where atom is an internal atom for the solver, and pr is a proof of |- lit = atom
val mk_atom_t : t -> ?⁠sign:bool -> term -> Atom.t * P.t
mk_atom_t _ ~sign t returns atom, pr where atom is an internal representation of ± t, and pr is a proof of |- atom = (± t)
val add_clause : t -> Atom.t Sidekick_util.IArray.t -> P.t -> 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 -> Atom.t list -> P.t -> unit
Add a clause to the solver, given as a list.
module Pre_proof : sig ... end
type res = 
| Sat of Model.t
Satisfiable
| Unsat of {
proof : Pre_proof.t option lazy_t;
proof of unsat
unsat_core : Atom.t list lazy_t;
subset of assumptions responsible for unsat
}
Unsatisfiable
| 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 -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:Atom.t list -> t -> res
solve s checks the satisfiability of the clauses added so far to s.
parameter check
if true, the model is checked before returning.
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 on_exit
functions to be run before this returns
val pp_stats : t CCFormat.printer
Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file
diff --git a/dev/sidekick/Sidekick_th_data/module-type-S/A/index.html b/dev/sidekick/Sidekick_th_data/module-type-S/A/index.html
index 3668db72..70a93e54 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-S/A/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-S/A/index.html
@@ -1,2 +1,2 @@
 
-A (sidekick.Sidekick_th_data.S.A)
Module S.A
module Cstor : sig ... end
Constructor symbols.
val as_datatype : S.T.Ty.t -> (Cstor.t Iter.t, S.T.Ty.t) data_ty_view
Try to view type as a datatype (with its constructors)
val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) data_view
Try to view term as a datatype term
val mk_cstor : S.T.Term.state -> Cstor.t -> S.T.Term.t Sidekick_util.IArray.t -> S.T.Term.t
Make a constructor application term
val mk_is_a : S.T.Term.state -> Cstor.t -> S.T.Term.t -> S.T.Term.t
Make a is-a term
val mk_sel : S.T.Term.state -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
Make a selector term
val mk_eq : S.T.Term.state -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
Make a term equality
val ty_is_finite : S.T.Ty.t -> 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 : S.T.Ty.t -> bool -> unit
Modify the "finite" field (see ty_is_finite)
val proof_isa_split : S.T.Ty.t -> S.T.Term.t Iter.t -> S.P.t
val proof_isa_disj : S.T.Ty.t -> S.T.Term.t -> S.T.Term.t -> S.P.t
val proof_cstor_inj : Cstor.t -> int -> S.T.Term.t list -> S.T.Term.t list -> S.P.t

\ No newline at end of file
+A (sidekick.Sidekick_th_data.S.A)
Module S.A
module Cstor : sig ... end
Constructor symbols.
val as_datatype : S.T.Ty.t -> (Cstor.t Iter.t, S.T.Ty.t) data_ty_view
Try to view type as a datatype (with its constructors)
val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) data_view
Try to view term as a datatype term
val mk_cstor : S.T.Term.store -> Cstor.t -> S.T.Term.t Sidekick_util.IArray.t -> S.T.Term.t
Make a constructor application term
val mk_is_a : S.T.Term.store -> Cstor.t -> S.T.Term.t -> S.T.Term.t
Make a is-a term
val mk_sel : S.T.Term.store -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
Make a selector term
val mk_eq : S.T.Term.store -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
Make a term equality
val ty_is_finite : S.T.Ty.t -> 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 : S.T.Ty.t -> bool -> unit
Modify the "finite" field (see ty_is_finite)
val proof_isa_split : S.T.Ty.t -> S.T.Term.t Iter.t -> S.P.t
val proof_isa_disj : S.T.Ty.t -> S.T.Term.t -> S.T.Term.t -> S.P.t
val proof_cstor_inj : Cstor.t -> int -> S.T.Term.t list -> S.T.Term.t list -> S.P.t

\ No newline at end of file