Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

awesome-rust-formalized-reasoning

An exhaustive list of all Rust resources regarding automated or semi-automated formalization efforts in any area, constructive mathematics, formal algorithms, and program verification.
https://github.com/newca12/awesome-rust-formalized-reasoning

Last synced: 3 days ago
JSON representation

Projects
- Provers and Solvers
  - Proost - simple proof assistant.
  - ~~slp~~ - became SolHOP.
  - ~~cobalt~~ - a wip minimal proof assistant.
  - Serkr - automated theorem prover for first order logic with equality.
  - lazyCoP - automatic theorem prover for first-order logic with equality.
  - lerna - proves theorems.
  - lickety - prototype system for linear resolution with splitting.
  - theorem-prover-rs - rewrite of [theorem-prover-kt](https://github.com/boitsov14/theorem-prover-kt) a sequent-style automated theorem prover.
  - BatSat - solver forked from ratsat, a reimplementation of MiniSat.
  - Colombini-SAT - simple 3-SAT solver.
  - CreuSAT - formally verified SAT solver verified with Creusot.
  - Debug-SAT - debuggable automatic theorem prover for boolean satisfiability problems (SAT).
  - dpll-sat - naïve SAT solver implementing the classic DPLL algorithm.
  - DRSAT - Daniel's Rusty SAT solver.
  - lutrix - SAT/SMT Solver.
  - minisat-rust - experimental minisat SAT solver.
  - msat - MaxSAT Solver.
  - RatSat - bin):star::zzz: - reimplementation of MiniSat.
  - Resolvo - fast package resolver (CDCL based SAT solving).
  - rsat - SAT Solver.
  - RsBDD - Reduced-order Binary Decision Diagram (RoBDD) SAT solver.
  - rust-sat - SAT solver that accepts input in the DIMACS CNF file format.
  - rustsat(2) - toy SAT solver.
  - sat - simple CDCL sat solver.
  - SAT solver - SAT solver.
  - SAT-MICRO - 00202831/en) - reimplementation of the SAT-solver described in 'SAT-MICRO: petit mais costaud!'.
  - sat-solver - simple CDCL SAT solver based on the lecture 185.A93 Formal Methods in CS at TU Wien.
  - SATCoP - theorem prover for first-order logic based on connection tableau and SAT solving.
  - Satire - educational SAT solver.
  - satyrs - DPLL SAT solver.
  - scrapsat - CDCDL SAT Solver.
  - screwsat - simple CDCL SAT Solver.
  - Scuttle - proc) - multi-objective MaxSAT solver based on the rustsat library and the CaDiCaL SAT solver.
  - SolHOP - aims to be a SAT and MaxSAT solver. Currently, a CDCL based SAT.
  - Splr - modern CDCL SAT solver.
  - starlit - CDCL SAT solver.
  - Stevia - simple (unfinished) SMT solver for QF_ABV.
  - UASAT-RS - SAT solver based calculator for discrete mathematics and universal algebra.
  - Varisat - checker)[:package:](https://crates.io/crates/varisat-cli)[:package:](https://crates.io/crates/varisat-dimacs)[:package:](https://crates.io/crates/varisat-formula)[:package:](https://crates.io/crates/varisat-internal-macros)[:package:](https://crates.io/crates/varisat-internal-proof)[:package:](https://crates.io/crates/varisat-lrat):star: - CDCL based SAT solver.
  - ellp - linear programming library that provides primal and dual simplex solvers.
  - minilp - linear programming solver.
  - hakim - hacky interactive theorem prover.
  - Esther - simple automated proof assistant.
  - homotopy-rs - implementation of homotopy.io proof assistant.
  - LSTS - proof assistant that is also a programming language.
  - Noq - Dvs8t0VZVE64QKPf6y_TIUwj5nKQ7):star: - Not Coq. Simple expression transformer that is not Coq.
  - Poi - pragmatic point-free theorem prover assistant.
  - qbar - experimental automated theorem verifier/prover and proof assistant.
  - Avalog - experimental implementation of Avatar Logic with a Prolog-like syntax.
  - autosat - automatic conversion of functions to CNF for SAT solving.
  - bootfrost - automated theorem proving program for first-order formulas with extensions.
  - Caso - category Theory Solver for Commutative Diagrams.
  - cyclegg - cyclic theorem prover for equational reasoning using egraph.
  - good_lp - Mixed Integer Linear Programming modeler using external solvers.
  - gpp-solver - solver) - small hybrid push-pull solver/planner that has the best of both worlds.
  - hoice - ICE-based Constrained Horn Clause (CHC) solver.
  - linear_solver - linear solver designed to be easy to use with Rust enums.
  - Logic solver - logic solver.
  - Mikino - simple induction and BMC engine.
  - Monotonic-Solver - monotonic solver designed to be easy to use with Rust enum expressions.
  - nnoq - simple theorem prover (nay, verifier) based on functional expression rewriting.
  - nyaya - proof language based on [sequent calculus](https://en.wikipedia.org/wiki/Sequent_calculus) and [Metamath](https://us.metamath.org).
  - Obvious - simple little logic solver and calculator.
  - pocket_prover - derive):star: - fast, brute force, automatic theorem prover for first order logic.
  - prover - first-order logic prover.
  - prover(2) - experiment with integer relation prover.
  - QED Prover - chu.pdf) - reimplementation of the Cosette prover in Rust.
  - reachability_solver - linear reachability solver for directional edges.
  - relsat-rs - Experiments with provers.
  - SAT-bench - benchmark suit for SAT solvers.
  - sat_lab - framework for manipulating SAT problems.
  - SAT solver ANalyser - toolbox for analyzing performance and runtime characteristics of SAT solvers.
  - sequentprover - proof search algorithm for boolean formulae.
  - Sequent solver - simple sequent solver.
  - shari - the 🍣 prover.
  - stupid-smt - SMT library. Mainly project at the verification course in THU.
  - Tensor Theorem Prover - first-order logic theorem prover (support unification with approximate vector similarity).
  - theorem-prover - implementation of a theorem prover for first-order logic.
  - Totsu - first-order conic solver for convex optimization problems .
  - peano - An environment for learning formal mathematical reasoning from scratch.
  - meancop - became CoP.
  - Colombini-SAT - simple 3-SAT solver.
  - SAT Solver(2) - simple SAT solver.
  - backdoor-solver - backdoor-based SAT solver.
  - simple-sat - one of the SAT solvers of all time.
  - res-rs - first bits for first-order logic prover.
  - microlp - linear programming solver (fork of [minilp](https://github.com/ztlpn/minilp)).
- Verification
  - crux-mir - static simulator for Rust programs.
  - Rust static analysis/verification reading and resources - for further reading.
  - Rust verification tools (2021) - list of Rust verification tools with a bias towards ‘formal methods’ tools.
  - Rust verification tools list - list of tools.
  - t3p - optimized TESC (Theory-Extensible Sequent Calculus) verifier.
  - coq-of-rust - formal verification for Rust.
  - contracts - implements "[Design By Contract](https://en.wikipedia.org/wiki/Design_by_contract)" via procedural macros.
  - cwe_checker - finds vulnerable patterns in binary executables.
  - electrolysis - tool for formally verifying Rust programs by transpiling them into the Lean 2 theorem prover.
  - Flux - izcFCHN2o):star:[:lab_coat:](https://arxiv.org/pdf/2207.04034.pdf):fire: - refinement type checker for Rust.
  - Granite - find Deadlocks in Rust with Petri-Net Model checking.
  - Kani - verifier):star:[:lab_coat:](https://www.cs.cornell.edu/~avh/dyn-trait-icse-seip-2022-preprint.pdf):fire: - bit-precise model-checker, ensures that unsafe Rust code is actually safe.
  - Liquid Rust - implement Liquid Types type checker.
  - lockbud - study.pdf) - statically detect deadlocks bugs for Rust.
  - Logically Qualified Data Types - implementation of liquid types on an implicitly-typed variant of ML.
  - Loom - concurrency permutation testing tool for Rust.
  - matla - a manager for TLA+ projects.
  - MIRAI - annotations):star: - intended to become a widely used static analysis tool for Rust.
  - MirChecker - simple static analysis tool.
  - p4-analyzer - static analysis tool which checks P4 code for bugs.
  - Prusti - contracts)[:package:](https://crates.io/crates/prusti-contracts-proc-macros)[:package:](https://crates.io/crates/prusti-specs)[:package:](https://crates.io/crates/prusti-std):star::fire: - prototype verifier for Rust, built upon the the Viper verification infrastructure.
  - Rudra - gatech/Rudra/blob/master/rudra-sosp21.pdf) - static analyzer to detect common undefined behaviors in Rust programs.
  - Rust Software Verification Benchmarks - collection of Rust verification benchmarks with their verifier crates.
  - Rust verification tools - collection of tools/libraries about static and dynamic verification of Rust programs.
  - RustHorn - 3-030-44914-8_18) - CHC-based Automated Verification Tool for Rust.
  - RustHornBelt Library & Benchmarks - evaluation libraries and benchmarks for the RustHornBelt PLDI paper.
  - Rustproof - compiler plugin, verification condition generator.
  - Shuttle - library for testing concurrent Rust code.
  - Stateright - model checker for implementing distributed systems.
  - VeriWasm - SFI verifier of Wasm binaries.
  - Xori - static analysis library for PE32, 32+ and shellcode.
  - ArcsJs - Provable - set of ArcsJs focused tools for doing proofs on ArcsJs models.
  - Bounded Registers - registers):star: - high-assurance memory-mapped register interaction library.
  - Carcara - proof checker and elaborator for SMT proofs in the [Alethe format](https://verit.gitlabpages.uliege.be/alethe/specification.pdf).
  - ceetle - library for defining models in Computational Tree Logic and verifying their semantics.
  - Chalk - solve)[:package:](https://crates.io/crates/chalk-derive)[:package:](https://crates.io/crates/chalk-engine)[:package:](https://crates.io/crates/chalk-ir)[:package:](https://crates.io/crates/chalk-macros)[:package:](https://crates.io/crates/chalk-recursive)[:package:](https://crates.io/crates/chalk-rust-ir):star: - implements the Rust trait system, based on Prolog-ish logic rules.
  - Charon - interface with the rustc compiler for the purpose of program verification.
  - Kinō - re-implementation of the core verification engine of [Kind 2 model-checker](https://kind2-mc.github.io/kind2).
  - Kontroli - parse)[:package:](https://crates.io/crates/kocheck)[:package:](https://crates.io/crates/kontroli):star::diamonds:[:tv:](https://www.youtube.com/watch?v=lLjWBsU_BX0)[:lab_coat:](https://arxiv.org/pdf/2102.08766.pdf) - alternative implementation of the logical framework Dedukti.
  - Metamath-knife - rs):star: - verify Metamath proofs.
  - Mist - userfriendly verification frontend language.
  - Mizar proof checker - Alternative [Mizar](http://mizar.org) proof checker.
  - pocket_prover-set - set) - base logical system for PocketProver to reason about set properties.
  - rate - common)[:package:](https://github.com/krobelus/rate)[:package:](https://crates.io/crates/rate-proof-utils)[:package:](https://crates.io/crates/rate-sick-check):diamonds:[:lab_coat:](https://github.com/krobelus/rate-experiments/blob/master/thesis.pdf) - clausal proof checker (DRAT, DPR) for certifying SAT solvers' unsatisfiability results.
  - rlfsc - checker for the LFSC proof language.
  - second_opinion - verifier for Metamath Zero proof files.
  - smetamath - parallel and incremental verifier for Metamath databases.
  - Temporal Verifier - framework for temporal verification based on first-order linear-time temporal logic.
  - verifiable-controllers - framework to build practical, formally verified, cluster management controllers.
  - Verifier - verifier):zzz: - Trivial proof verifier - an interface to the Metamath Zero kernel.
  - Creusot - tool for deductive verification of Rust code.
  - verus - zS4ZCY)[:lab_coat:](https://arxiv.org/abs/2303.05491) - verified subset of Rust for low-level systems code.
  - Charon - interface with the rustc compiler for the purpose of program verification.
  - Supervisionary - XowAo)[:lab_coat:](https://dominicpm.github.io/publications/mulligan-supervisionary-2022.pdf) - experimental proof-checking system for Gordon's higher-order logic.
  - RefinedRust - type system for high-assurance verification of Rust Programs.
- Libraries
  - logic-parser - parser):mortar_board: - library for lexing, parsing and visualizing logical expressions.
  - mm0-rs - slides.pdf)[:lab_coat:](https://digama0.github.io/mm0/thesis.pdf) - MM0/MM1 server and utilities.
  - ~~rust-unify~~ - unify) :recycle: - unification algorithum implementation.
  - CNF Parser - parser):zzz: - efficient and customizable parser for the .cnf file format.
  - coq-rs - this program can parse Coq .vo files.
  - DIMACS Parser - utilities to parse files in DIMACS .cnf or .sat file format.
  - Exec-SAT - sat):baby_chick: - provides routines to parse SAT solver output and to execute SAT solver.
  - Flussab CNF - cnf) - parsing and writing of the DIMACS CNF file format.
  - FRAT-rs - toolchain for processing and transforming files in the FRAT format.
  - Lambda Calculus Parser - λ-calculus parser.
  - Lambda Term Parsing - explores different parser designs for a simple lambda term grammar.
  - logic-form - form):baby_chick: - library for representing Cube, Clause, CNF and DNF.
  - lp_parser_rs - LP file parser.
  - mmb-parser - parser) - parser for the Metamath Zero binary proof format.
  - mps - fast MPS parser.
  - olean-rs - parser/viewer for olean files.
  - RustLogic - march1917) - parsing and handling simple logical expressings.
  - smt2 - SMT-LIB 2 parsing library.
  - tptp - parse the TPTP format.
  - boolector - safe high-level bindings for the [Boolector](https://boolector.github.io) SMT solver.
  - bitwuzla-sys - sys) - low-level bindings for the [Bitwuzla](https://bitwuzla.github.io) SMT solver.
  - boolector-sys - sys) - low-level bindings for the [Boolector](https://boolector.github.io) SMT solver.
  - cadical-rs - bindings for the CaDiCaL SAT solver.
  - cat_solver - bindings for the Kissat SAT solver.
  - cplex-rs - rs)[:package:](https://crates.io/crates/cplex-rs-sys) - safe rust bindings for [CPLEX](https://www.ibm.com/products/ilog-cplex-optimization-studio/cplex-optimizer).
  - cryptominisat-rs - bindings for [CryptoMiniSat](https://github.com/msoos/cryptominisat).
  - falcon-z3 - z3) - bindings for Z3.
  - highs - safe rust bindings for the [HiGHS](https://highs.dev) linear programming solver.
  - highs-sys - sys) - bindings for the [HiGHS](https://highs.dev) linear programming solver.
  - IPASIR - FFI bindings for the IPASIR incremental SAT solver interface.
  - isabelle-client - client) - client to interact with an [Isabelle](https://isabelle.in.tum.de) server.
  - Kissat-rs - bindings for the Kissat SAT solver.
  - lean-sys - sys) - bindings to Lean 4's C API.
  - libsmt.rs - bindings for SMTLIB2.
  - maxpre-rs - bindings for the (multi-objective) MaxSAT preprocessor MaxPre.
  - pblib-rs - rs) - safe bindings for [pblib](https://github.com/master-keying/pblib).
  - rplex - bindings for [CPLEX](https://www.ibm.com/products/ilog-cplex-optimization-studio/cplex-optimizer).
  - rsmt2 - zz):star: - generic library to interact with SMT-LIB 2 compliant solvers.
  - russcip - safe Rust interface for [SCIP](https://www.scipopt.org).
  - Rust-SMT-LIB-API - generic high-level API for interacting with SMT solvers.
  - rust_z3prover - use Z3 SMT solver from rust.
  - rustproof-libsmt - libsmt):zzz: - fork of libsmt.rs.
  - SAT Nexus - interfaces and wrappers for SAT solvers.
  - scip-sys - sys) - raw rust bindings to [SCIP](https://www.scipopt.org).
  - smt_sb-rs - rs) - Z3 SMT Simple Binding.
  - smtlib - lowlevel)[:package:](https://crates.io/crates/smtlib-build-util) - high-level API for interacting with SMT solvers.
  - vipers - crates for interacting with the Viper verification infrastructure.
  - Yices2 - sys) - low and high-level bindings to the [Yices2](https://yices.csl.sri.com/) SMT solver.
  - z3 - sys):star::fire: - high-level and low-level Rust bindings for the Z3 solver.
  - z3-rust - high level bindings for the Microsoft's Z3 SMT solver.
  - Z3D - Z3 DSL interface.
  - anthem - translate answer set programs to first-order theorem prover language.
  - bool2dimacs - transfer boolean expression to dimacs directly.
  - CNFGEN - create boolean formulae from boolean expressions and integer expressions.
  - Cnfpack - converts between DIMACS CNF file format and the compressed binary Cnfpack format.
  - hz-to-mm0 - translator from HOL Zero / Common HOL to Metamath Zero.
  - Metamath hammer - tool for automatically proving Metamath theorems using ATPs.
  - rust-smt-ir - smt-ir)[:package:](https://crates.io/crates/aws-smt-ir-derive):star: - intermediate representation (IR) in Rust for SMT-LIB queries.
  - AbsoluteUnity - think Prolog, but less capable.
  - Alice_rs - implementation of a decision procedure for A Decidable Fragment of Separation Logic.
  - auto - decision procedure for intuitionistic logic.
  - Avatar Hypergraph Rewriting - hypergraph rewriting system with avatars for symbolic distinction.
  - coc - the calculus of constructions.
  - compiler - compiler):baby_chick::zzz: - trivial compiler framework for Metamath Zero binary proofs.
  - discrimination-tree - tree) - discrimination tree term indexing.
  - easy-smt - smt):star: - easy SMT solver interaction (Inspired by the [simple-smt haskell](https://hackage.haskell.org/package/simple-smt) package.).
  - egg - flexible, high-performance e-graph library.
  - epilog - collection of Prolog-like tools for inference logic.
  - FALL - easily embeddable, futures-friendly logic engine.
  - foliage - first-order logic with integer arithmetics.
  - fuzzylogic - provides operations and inference for fuzzy set theory.
  - Joker Calculus - implementation of Joker Calculus in Rust.
  - Kravanenn - set of tools for Coq.
  - logic-lang - lang) - structural logic based on equivalence graphs.
  - logical_solver - library for solving and parsing logical equations.
  - LogRu - small, embeddable and fast interpreter for a subset of Prolog.
  - mmb-binutils - utility tools for Metamath Zero binary proof files.
  - mmb-types - types):zzz: - library containing the definitions of the opcodes in the Metamath Zero binary proof files.
  - moniker - derive):star::zzz: - automagical variable binding library.
  - nanoda - became nanoda-lib.
  - nanoda_lib - type inference/checking functionality based on the Lean theorem prover.
  - nnf - Negation Normal Form manipulation library.
  - polytype - Hindley-Milner polymorphic typing system.
  - program-induction - library for program induction and learning representations.
  - ruler - rewrite rule inference using equality saturation.
  - Rust First Order Logic - syntax of First Order Logic with self-consistent logical assertions.
  - rust-nbe-for-mltt - normalization by evaluation for Martin-Löf Type Theory with dependent records.
  - rustsat - batsat)[:package:](https://crates.io/crates/rustsat-cadical)[:package:](https://crates.io/crates/rustsat-glucose)[:package:](https://crates.io/crates/rustsat-ipasir)[:package:](https://crates.io/crates/rustsat-kissat)[:package:](https://crates.io/crates/rustsat-minisat)[:package:](https://crates.io/crates/rustsat-tools) - provide elements commonly used in satisfiability solving software.
  - Rusty Razor - fol)[:package:](https://crates.io/crates/razor-chase):star::zzz: - tool for constructing finite models for first-order theories.
  - sat_toasty_helper - convenient way to write and solve SAT constraints.
  - Satoxid - library to help with encoding SAT problems.
  - smt2utils - libraries and tools for the SMT-LIB-2 standard.
  - smtlib-syntax - syntax) - syntactic types the for the SMT-LIB 2.6 spec. Meant for code generation, not parsing.
  - term-rewriting-rs - representing, parsing, and computing with first-order term rewriting systems.
  - tribool - three-valued logic.
  - The Trivial Metamath Zero kernel - kernel):zzz: - Metamath Zero kernel for Trivial.
  - Whisper - logic Programming DSL.
  - lpsolve - sys):zzz: - high-level [lpsolve](https://sourceforge.net/projects/lpsolve) wrapper.
  - clingo-rs - derive)[:package:](https://crates.io/crates/clingo-sys):star: - idiomatic bindings to the [clingo](https://github.com/potassco/clingo) library.
  - LogicNG - library for creating, manipulating and solving Boolean and Pseudo-Boolean formulas.
  - polytype - Hindley-Milner polymorphic typing system.
  - program-induction - library for program induction and learning representations.
  - smt2utils - libraries and tools for the SMT-LIB-2 standard.
  - Patronus - btor2 parser, wip hardware bug-finding toolkit.
  - rust-smt-strings - smt-strings) - library for strings as defined in the SMT-LIB theory of strings.
  - isabelle export tool - parser for isabelle database files.
  - rssat - provides Rust bindings for multiple popular SAT solvers.
Resources
- Community
  - Sven Nilsen - Avalog, Avatar Hypergraph Rewriting, Caso, Debug-SAT, Joker Calculus, Last Order Logic, linear_solver, Monotonic-Solver, pocket_prover, pocket_prover-set, Poi, Prop, reachability_solver.
  - Mark Verleg - prover(2).
  - Shuxian Wang - QED Prover.
  - David A. Wheeler - Metamath-knife.
  - Max Willsey - egg, egglog.
  - Ivo Wingelaar - compiler, mmb-binutils, mmb-parser, mmb-types, The Trivial Metamath Zero kernel, Verifier.
  - Jieyou Xu - Propositional Tableaux Solver.
  - Nikita Voronov - RLCI.
  - Ren Yanjie - bool2dimacs, RustLogic.
  - Brendan Zabarauskas - Fathom, moniker, Pikelet, rust-nbe-for-mltt.
  - Bas Zalmstra - Resolvo.
  - Alexey Zatelepin - minilp.
  - Eric Zhang - µKanren-rs.
  - Hanliang Zhang - sat.
  - Tesla Ice Zhang - minitt-rs, Narc, Voile.
  - Felix Zhu - lambdacube.
  - Li Zhuohua - MirChecker.
  - Mikko Aarnos - Serkr.
  - Johannes Altmanninger - rate.
  - ammkrn - nanoda, nanoda_lib, second_opinion.
  - Bruno Andreotti - Carcara.
  - Arata - lutrix.
  - arbaregni - resolution-prover.
  - astrobeastie - sequentprover.
  - Yechan Bae - Rudra, Satire.
  - Clark Barrett - Rust-SMT-LIB-API.
  - Mathieu Baudet - smt2utils.
  - Mike Beaumont - rust-sat.
  - Tim Beurskens - RsBDD.
  - Justin Blanchard - cat_solver.
  - boitsov14 - theorem-prover-rs.
  - Henrik Böving - Obvious.
  - Oliver Bøving - Mist, smtlib, vipers.
  - Bickio O'Callahan - Solving The Witness with Z3.
  - Tej Chajed - Temporal Verifier.
  - Adrien Champion - hoice, Kinō, matla, Mikino, rsmt2, SAT-MICRO, Verification for Dummies.
  - David Chanin - Tensor Theorem Prover.
  - Michelle Cheatham - rusty-logic.
  - Alex Chew - Z3D.
  - Konstantin Chukharev - SAT Nexus, backdoor-solver.
  - Cobalt - SAT solver ANalyser.
  - Lorenzo Colombini - Colombini-SAT.
  - convexbrain - Totsu.
  - David Cox - mps.
  - Simon Cruanes - BatSat.
  - Dacit - Sequent solver.
  - dandxy89 - lp_parser_rs.
  - DavidD12 - SMT-language, smt_sb-rs.
  - Sylvie Dirkswager - Pika.
  - Craig Disselkoen - boolector.
  - Mark Drobnak - p4-analyzer.
  - Bruno Dutertre - rust-smt-ir, rust-smt-ir-examples, rust-smt-strings.
  - Thomas Dziedzic - lambda_calculus.
  - Ariel Davis - coc.
  - Xavier Denis - Creusot, RustHornBelt: A Semantic Foundation for Functional Verification of Rust Programs with Unsafe Code, RustHornBelt Library & Benchmarks, Rust verification tools (2021), Specifying and Verifying Higher-order Rust Iterators (2023), A hybrid approach to semi-automated Rust verification (2024), Visions of the future: formal verification in Rust.
  - Sushant Dinesh - libsmt.rs.
  - Trevor Elliott - auto, easy-smt.
  - endeav0r - falcon-z3.
  - Enkelmann - cwe_checker.
  - Aodhnait Étaín - Esther.
  - Michael Färber - CoP, Kontroli, Lambda Term Parsing, meancop, research notebook about improving with Rust the performance of nonclausal automated theorem provers.
  - FireFighterDuck - Alice_rs, Kissat-rs, minihl.
  - Paolo Flores - logic-parser.
  - Hugo Frezat - logic-lang.
  - Robin Freyler - CNF Parser, DIMACS Parser, Stevia.
  - Galois, Inc. - crux-mir.
  - Alexey Gerasimov - Liquid Rust.
  - Jad Ghalayini - isotope-prover-experiments, lean-sys.
  - Brandon H. Gomes - qbar.
  - Robert Grosse - cryptominisat-rs.
  - Masaki Hara - Logic solver, RatSat.
  - Jannis Harder - Cnfpack, Flussab CNF, Minimal models, starlit, Varisat, Varisat notebook.
  - Son HO - Charon.
  - Sarek Høverstad Skotåm - CreuSAT.
  - Hoblovski - stupid-see, stupid-smt.
  - Emil Hofstetter - mini-prop, prop_tune.
  - hrkzmnm - rust_z3prover.
  - Tero Huttunen - proto-vulcan.
  - Christoph Jabs - Scuttle, maxpre-rs, rustsat.
  - David S. Hardin - Hardware/Software Co-Assurance using the Rust Programming Language and ACL2, Verification of a Rust Implementation of Knuth's Dancing Links using ACL2.
  - Jan - Plogic.
  - Ranjit Jhala - flux-demo.
  - Andrew Johnson - LSTS, Pun Calculus, Relog.
  - Evan Johnson - VeriWasm.
  - Dylan R. Johnston - Formally Verifying Rust's Opaque Types.
  - Matthias Jugan - LogicNG, logicng-open-wbo-sys.
  - Ralf Jung - Understanding and Evolving the Rust Programming Language.
  - Carl Kadie - Check AI-Generated Code Perfectly and Automatically.
  - Hosein Kalbasi - akim.
  - Rowan Hart - Yices2.
  - Timothée Haudebourg - smt2.
  - Reuben Hillyard - beta.
  - Igor Kalichevski - nnf.
  - karroffel - contracts.
  - Anto Keinänen - logical_solver, logical_tui.
  - Rahul Kumar - How Open Source Projects are Using Kani to Write Better Software in Rust.
  - Prateek Kumar - msat, rsat, slp, SolHOP.
  - Alexey Kutepov - Noq.
  - Ivan Ladelshchikov - nonogrid.
  - Andrea Lattuada - verus.
  - lcnr - cobalt.
  - Shea Leffler - tarpit-rs, whisper.
  - Nico Lehmann - Flux.
  - Carl Lerche - Loom.
  - Chuck Liang - Lambdascript.
  - Nathan Lilienthal - lambash, lalrpop-lambda.
  - ljedrz - blc, lambda_calculus.
  - Ophir LOJKINE - highs, highs-sys, good_lp.
  - Emmanuel Lonca - pblib-rs.
  - Patrick Lühne - anthem, foliage.
  - Michael Madden - Xori.
  - Scott J Maddox - Untyped Concatenative Calculus, Untyped Multistack Concatenative Calculus.
  - Indraneel Mahendrakumar - Lamb.
  - Harald Maida - Lamcal.
  - Krzysztof Małysa - prover.
  - Manas - fuzzylogic.
  - Miklos Maroti - cadical-rs, relsat-rs, uasat-rs.
  - marshtompsxd - verifiable-controllers.
  - Niko Matsakis - Chalk, Kani, plar-rs.
  - Yusuke Matsushita - Extensible Functional-Correctness Verification of Rust Programs by the Technique of Prophecy, RustHorn.
  - mbillingr - miniKANREN, The Little Prover, the-little-typer.
  - mcmfb - lambda_calc.
  - Tom Meyer - Granite.
  - Alexander Mishunin - minisat-rust.
  - Proloy Mishra - lam, nnoq, nyaya.
  - Bruce Mitchener - z3.
  - Lucas Morales - polytype, program-induction.
  - Jesse Mu - satyrs.
  - Dominic Mulligan - Supervisionary.
  - Jon Nadal - Stateright.
  - Chandrakana Nandi - Ruler.
  - neuring - rummy_to_sat, Satoxid.
  - Yuichi Nishiwaki - shari.
  - Stefan O'Rear - smetamath.
  - Robert Obkircher - sat-solver.
  - Adolfo Ochagavía - An adventure with optimization, Rust and Z3.
  - Edgar Onghena - inf402.
  - Alex Ozdemir - rlfsc.
  - Chris Patuzzo - Supermux, Supersat.
  - Pierre-Marie Pédrot - Kravanenn.
  - Arvid E. Picciani - zz.
  - Dan Pittman - Bounded Registers.
  - Gabriel Poesia - peano.
  - Nadia Polikarpova - cyclegg.
  - Christian Poveda - Chevre.
  - Bobby Powers - Logically Qualified Data Types.
  - Joshua Pratt - ArcsJs - Provable, tako.
  - petersn - autosat.
  - Boqin Qin - lockbud.
  - Armaan Rashid - implies.
  - Michael Rawson - discrimination-tree, lazyCoP, lerna, lickety, SATCoP, tptp.
  - Alastair Reid - Articles about a collection of tools/libraries to support both static and dynamic verification of Rust programs, Rust Software Verification Benchmarks, Rust verification tools, Rust verification tools list.
  - Adrien Renaudineau - sat_lab.
  - Nathan Ringo - FALL.
  - Benjamin Rogers-Newsome - Rust First Order Logic.
  - Erik Rohkohl - n-queens-sat.
  - Marco Concetto Rudilosso - validator.
  - Josh Rule - formal-systems-learning-rs, list-routine-learning-rs, term-rewriting-rs.
  - Salman Saghafi - rust-z3-practice, Rusty Razor.
  - Michael Salter - Rustproof, rustproof-libsmt.
  - Daniel Schemmel - DRSAT.
  - Ryan Schroeder - AbsoluteUnity, epilog.
  - Carol Schulze - gpp-solver.
  - shinkwhek - SAT solver.
  - skbaek - t3p.
  - Narazaki Shuji - SAT-bench, Splr, Splr notebook, sudoku_sat.
  - SnO₂WMaN - rust-proplogic-toylang.
  - snsinfu - dpll-sat.
  - Mikhail Solovev - bitwuzla-sys, boolector-sys.
  - Dennis Sprokholt - aws-lambda-z3, Rust pi-forall.
  - Will Sturgeon - Junglefowl.
  - Yuheng Su - logic-form.
  - SymmetricChaos - tnt.
  - Mateusz Szpakowski - CNFGEN, Exec-SAT.
  - Lucas Tabary-Maujean - Proost.
  - Victor Taelin - High-order Virtual Machine (HVM), Kind2, Symmetric Interaction Calculus..
  - Calin Tataru - homotopy-rs.
  - Mark Thom - Scryer Prolog.
  - Fabian Thorand - LogRu.
  - Hitoshi Togasaki - scrapsat, screwsat.
  - Callum Tolley - plc
  - Aaron Trent - tribool.
  - Sebastian Ullrich - A Formal Verification of Rust's Binary Search Implementation, electrolysis, Simple Verification of Rust Programs via Functional Purification.
  - V4kst1z - tapl, TIP.
  - Alexa VanHattum - Artifact Evaluation: Kani Rust Verifier (Kani).
  - Pavol Vargovčík - z3-rust.
  - Herman Venter - MIRAI, Rust static analysis/verification reading and resources.
  - Graydon Hoare - Some notes on Rust, mutable aliasing and formal verification.
  - Prateek Kumar - msat, rsat, slp, SolHOP.
  - Kevin Lotz - isabelle-client.
  - jzbor - Lambda Shell.
  - Aleksandr Larionov - bootfrost.
  - Azeez Daoud - ceetle.
  - Michael Färber - CoP, Kontroli, Lambda Term Parsing, meancop, research notebook about improving with Rust the performance of nonclausal automated theorem provers.
  - Michael Rawson - discrimination-tree, lazyCoP, lerna, lickety, SATCoP, tptp.
  - William Goodall - roq.
  - Paweł Jastrzebski - Propositional Logic.
  - Matteo Biggio - cplex-rs.
  - Kurt Ehlert - ellp.
  - Mohammed Ghannam - russcip, scip-sys.
  - Hugo Peters - Cracking the Cryptic (with Z3 and Rust).
  - Corey Richardson - lpsolve.
  - J David Smith - rplex.
  - Jimmy Chen Chen - theorem-prover.
  - Nathan Graule - rs-logik.
  - Alessandro Legnani - VeriFactory.
  - Jan Winkelmann - smtlib-syntax.
  - Antoine Belvire - Croissant.
  - Nathan Fenner - sat_toasty_helper.
  - Lee ByeongJun - Lambda Calculus Parser.
  - Guillaume Claret - coq-of-rust, Formal Land.
  - Klas Segeljakt - type-theory.
  - Jörg Singer - raa_tt.
  - Lorenzo Colombini - Colombini-SAT.
  - Craig Disselkoen - boolector.
  - James Bornholt - rustsat(2), Shuttle.
  - Mario Carneiro - coq-rs, FRAT-rs, hz-to-mm0, isabelle export tool, Metamath hammer, Metamath-knife, Mizar proof checker, mm0-rs, olean-rs.
- Research Paper & Thesis
- Blogs
- Posts
  - How Open Source Projects are Using Kani to Write Better Software in Rust - 2023.
  - Check AI-Generated Code Perfectly and Automatically - 2023.
  - Solving The Witness with Z3 - 2022.
  - Formally Verifying Rust's Opaque Types - 2022.
  - An adventure with optimization, Rust and Z3 - 2019.
  - Some notes on Rust, mutable aliasing and formal verification - 2024
  - Some notes on Rust, mutable aliasing and formal verification - 2024
  - Cracking the Cryptic (with Z3 and Rust) - 2024
  - Visions of the future: formal verification in Rust - 2024
- Crates keywords
  - smt - 43 entries. :100:
  - satisfiability - 26 entries. :100:
  - linear-programming - 17 entries. :100:
  - smt-lib - 12 entries. :100:
  - cnf - 10 entries. :100:
  - rewriting - 9 entries. :100:
  - prover - 8 entries. :100:
  - first-order - 6 entries. :100:
  - z3 - 6 entries. :100:
  - dependent-types - 6 entries. :100:
  - metamath-zero - 5 entries. :100:
  - dimacs - 5 entries. :100:
  - verification - 48 entries. :100:
  - sat-solver - 8 entries. :100:
  - proving - 13 entries. :100:
  - solver - 124 entries. :100:
  - logic - 87 entries. :100:
  - sat - 38 entries. :100:
- Books
  - Verification for Dummies: SMT and Induction - broadly discusses induction as a formal verification technique.
- Demos
  - Artifact Evaluation: Kani Rust Verifier - trait-icse-seip-2022-preprint.pdf) - Kani Rust Model Checker artifact for ICSE 2022 Artifact Evaluation.
  - flux-demo - small examples that demonstrate how flux works.
  - rust-smt-ir-examples - examples of using a rust-smt-ir, a Rust intermediate representation (IR) for SMT-LIB.
  - aws-lambda-z3 - tutorial on running Z3 on AWS Lambda, with Rust.
Books code
- Libraries
  - numerous
  - logic-rs - meaning-and-argument/lepore-about-the-book):star::zzz: - parser of relational predicate logic & truth tree solver
  - plar-rs - rs) - exploring John Harrison's Handbook of Practical Logic and Automated Reasoning.
  - tapl - implementation of TAPL.
  - TAPL in Rust - another collection of implementations of TAPL.
  - The Little Prover - little-prover) - transpiled J-Bob assistant & GUI frontend.
  - the-little-typer - little-typer) - a Rust take on D.Friedman's book.
  - tnt - implementation of Hofstader's "Typographical Number Theory" from the book Gödel, Escher & Bach.
  - types-and-programming-languages - Exercises from Benjamin Pierce's TAPL textbook + extras!
Lambda Calculus
- Libraries
  - ~~lambda_calc~~ - command-line untyped lambda calculus interpreter.
  - blc - implementation of the binary lambda calculus.
  - Closure Calculus - library for Barry Jay's Closure Calculus.
  - lam - lambda calculus evaluator.
  - Lamb - implementation of the pure untyped lambda calculus in modern, safe Rust.
  - lambash - λ-calculus shell.
  - lambda_calculus - simple, zero-dependency implementation of pure lambda calculus in safe Rust.
  - lambda_calculus - lambda calculus with antlr grammar.
  - lambdacube - implementation of the lambda cube (and other type stuff).
  - Lambda Shell - simple REPL shell for untyped lambda expressions.
  - Lambdascript - educational tool illustrating beta reduction of untyped lamba terms.
  - Lamcal - repl):zzz: - lambda calculus parser and evaluator and a separate command line REPL.
  - Pun Calculus - variant of Typed Lambda Calculus with generalized variable punning (ad-hoc polymorphism).
  - RLCI - Overly-documented Lambda Calculus Interpreter.
  - type-theory - typed λ-calculus.
  - lalrpop-lambda - lambda):star: - λ-calculus grammar/interpretor written using LALRPOP and `λ!`.
Propositional logic
- Libraries
  - ~~Chevre~~ - small propositional logic interpreter.
  - implies - storing logical formulas as parse trees and performing complex operations on them.
  - logic - crate for propositional logic.
  - logic-resolver - toy implementation of resolution for propositional logic.
  - mini-prop - prop) - CLI tool for parsing and processing LaTex formatted propositional statements.
  - plc - propositional logic calculator.
  - Plogic - propositional logic evaluator and rule-based pattern matcher.
  - Prop - library for theorem proving with Intuitionistic Propositional Logic.
  - Propositional Logic - propositional Logic Library .
  - Propositional Tableaux Solver - tableau-solver-rs):zzz: - solver using the propositional tableaux method.
  - prop_tune - library for working with Logical Propositions.
  - raa_tt - prover for sentences of propositional calculus.
  - Resolution Prover - resolution prover library for propositional logic.
  - resolution-prover - Uses propositional resolution to prove statements and proofs on discord.
  - rs-logik - logik) - propositional logic interpreter.
  - rust-proplogic-toylang - toy language for Propositional Logic.
  - rusty-logic - propositional logic analysis.
  - simple-proof-assistant - a proof assistant kernel for minimal propositional logic.
  - validator - small utility to test a propositional logic theorem prover.
About ##
- edla.org
- edla.org
Programming Language
- Libraries
  - beta - dependently-typed programming language, aiming to support a cubical interpretation of univalence.
  - egglog - language that combines the benefits of equality saturation and datalog.
  - Fathom - declarative data definition language for formally specifying binary data formats.
  - High-order Virtual Machine (HVM) - massively parallel, optimal functional runtime.
  - isotope-prover-experiments - proposal/-/blob/main/report.tex)[:lab_coat:](https://gitlab.com/isotope-project/msc-thesis/-/blob/master/thesis.tex):skull: - experimental dependently typed language supporting borrow checking.
  - Kind - next-gen functional language and proof assistant.
  - Last Order Logic - experimental logical language.
  - minihl - formal methods playgorund for MiniHeapLang language.
  - minitt-rs - util):star::skull: - became Voile.
  - Narc - dependently-typed programming language with Agda style dependent pattern matching.
  - Pika - small, performance-oriented, dependently typed ML with algebraic effects and unboxed types..
  - Pikelet - small, functional, dependently typed programming language.
  - proto-vulcan - vulcan)[:package:](https://crates.io/crates/proto-vulcan-macros) - miniKanren-family relational logic programming language.
  - Rust pi-forall - forall/blob/2022/doc/oplss.pdf) - partial re-implementation of pi-forall.
  - Scryer Prolog - prolog):star: - modern Prolog implementation.
  - SMT-language - lang) - Sat Modulo Theory Language.
  - stupid-see - symbolic execution engine. Mainly targeted at the verification course in THU.
  - tako - experimental programming language for ergonomic software verification.
  - TIP - imperative programming language aimed at teaching fundamental concepts of static program analysis.
  - Untyped Concatenative Calculus - toy programming language and prototype for [Dawn](https://www.dawn-lang.org).
  - Untyped Multistack Concatenative Calculus - toy programming language and prototype for [Dawn](https://www.dawn-lang.org).
  - Voile - util):star::zzz: - became Narc.
  - zz - zymbolic verifier and tranzpiler to bare metal C.
  - Last Order Logic - experimental logical language.
  - Pika - small, performance-oriented, dependently typed ML with algebraic effects and unboxed types..
  - Symmetric Interaction Calculus - optimal λ-calculus reduction. Followed devlopment now in Kind project.
  - rooc - a language for compiling formal mathematical models into static models.
Kanren
- Libraries
  - Canrun - logic programming library inspired by the *Kanren family of language DSLs.
  - miniKANREN - kanren):zzz: - miniKANREN as a DSL.
  - rslogic - logic programming framework for Rust inspired by µKanren.
  - rust-kanren - loose interpretation of miniKanren and cKanren.
  - µKanren-rs - implementation of µKanren.
  - rslogic - logic programming framework for Rust inspired by µKanren.
Unclassified
- Libraries
  - Croissant - crossword solver backed by various SAT solvers.
  - formal-systems-learning-rs - simulations to learn formal systems as typed first-order term rewriting systems.
  - inf402 - SAT-solver-based takuzu solver.
  - Junglefowl - macros) - runs Peano arithmetic on Rust types, verified at compile time..
  - list-routine-learning-rs - to learn typed first-order term rewriting systems that perform list routines.
  - logical_tui - tui for [logical_solver](https://github.com/antoKeinanen/logical_solver-rs).
  - Minimal models - uses a SAT solver to find minimal partial assignments that are model of a CNF formula.
  - n-queens-sat - modelling n-queens problem as conjunctive normal form and solving it with DPLL algorithm.
  - nonogrid - lightning fast nonogram solver.
  - Relog - implementation of several strongly-normalizing string rewriting systems.
  - roq - proc-macro Coq code generation and proof automation.
  - rummy_to_sat - implementation of a solver for [Rummy](https://en.wikipedia.org/wiki/Rummy).
  - rust-z3-practice - solving a number of SAT problems using Z3.
  - sudoku_sat - solve Sudoku variants with SAT solvers.
  - Supermux - reduction of the superpermutation problem to Quantified Boolean Formula.
  - Supersat - attempt to find superpermutations by reducing the problem to SAT.
  - tarpit-rs - type-level implementation of Smallfuck. Turing-completeness proof for Rust's type system.
  - VeriFactory - verifier for [Factorio blueprints](https://factorioprints.com).

Programming Languages

Rust 310 SMT 3 Python 2 Jupyter Notebook 2 C 2 HTML 1 Gnuplot 1 Haskell 1 Cuda 1 C++ 1

Ecosyste.ms: Awesome

awesome-rust-formalized-reasoning

Projects

Provers and Solvers

Verification

Libraries

Resources

Community

Research Paper & Thesis

Blogs

Posts

Crates keywords

Books

Demos

Books code

Libraries

Lambda Calculus

Libraries

Propositional logic

Libraries

About ##

Programming Language

Libraries

Kanren

Libraries

Unclassified

Libraries