Data

Tools

Indexes

Applications

Experiments

Awesome

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

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: 15 days ago
JSON representation

  • About ##

  • 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 - collection of implementations of TAPL (Chap 3-10,17,25).
      • 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 TAPL textbook + extras! (Chap 5-7,9-10)
      • TAPL Implementations - collection of implementations of TAPL (Chap 3-7,9,11,13-14,19,22).
      • program-proofs-prusti - proofs.com/) - examples and exercises from the book Program Proofs by K. Rustan M. Leino.
      • harrison-rust - library for SAT solving and automated theorem proving derived from the book.

  • 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.

  • Lambda Calculus

    • Libraries

      • ~~lambda_calc~~ - command-line untyped lambda calculus interpreter.
      • lalrpop-lambda - lambda):star: - λ-calculus grammar/interpretor written using LALRPOP and `λ!`.
      • 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.

  • 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 - 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.
      • rooc - a language for compiling formal mathematical models into static models.
      • Interaction Calculus - calculus):star: - programming language (fit the optimal λ-calculus reduction algorithm perfectly).
      • norem-lang - pure functional programming language with automatic verification and effect system.
      • reckon - programming language designed for reasoning tasks, proof checking, and logical inferencing.
      • Last Order Logic - experimental logical language.
      • Logicaffeine - language)[:package:](https://crates.io/crates/logicaffeine-compile)[:package:](https://crates.io/crates/logicaffeine-lsp)[:package:](https://crates.io/crates/logicaffeine-kernel)[:package:](https://crates.io/crates/logicaffeine-proof)[:package:](https://crates.io/crates/logicaffeine-lexicon)[:package:](https://crates.io/crates/logicaffeine-base)[:package:](https://crates.io/crates/logicaffeine-data)[:package:](https://crates.io/crates/logicaffeine-system)[:package:](https://crates.io/crates/logicaffeine-cli):star: - LOGOS compiles your words into programs, proofs, and formal systems.
      • Lean-Claude - rewrite Lean4 Compiler in Rust, using only Claude Code.
      • High-order Virtual Machine (HVM) - massively parallel, optimal functional runtime.

  • Projects

    • 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:[:lab_coat:](https://arxiv.org/abs/cs/0603080) - unification algorithum implementation.
      • lpsolve - sys):zzz: - high-level [lpsolve](https://sourceforge.net/projects/lpsolve) wrapper.
      • 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.
      • LogicNG - library for creating, manipulating and solving Boolean and Pseudo-Boolean formulas.
      • 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::zzz: - 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.
      • rust-smt-strings - smt-strings) - library for strings as defined in the SMT-LIB theory of strings.
      • 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/pigeons)[:package:](https://crates.io/crates/rustsat-tools):star: - 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.
      • clingo-rs - derive)[:package:](https://crates.io/crates/clingo-sys):star: - idiomatic bindings to the [clingo](https://github.com/potassco/clingo) library.
      • Patronus - btor2 parser, wip hardware bug-finding toolkit.
      • isabelle export tool - parser for isabelle database files.
      • rssat - bindings for multiple popular SAT solvers, superseded by satgalaxy-rs.
      • Decdnnf-rs - translating formulas generated by [d4](https://www.cril.univ-artois.fr/software/d4) into the format generated by [c2d](http://reasoning.cs.ucla.edu/c2d).
      • cadical-sys - sys) - almost complete safe and unsafe bindings for the CaDiCal SAT solver.
      • EasyZ3 - simplified API to get started with the z3 SAT solver.
      • lean-sys - sys):star: - bindings to [Lean 4](https://github.com/leanprover/lean4)'s C API.
      • satgalaxy-rs - FFI bindings for [satgalaxy-core](https://github.com/sat-galaxy/satgalaxy-core) bringing high-performance SAT solving to Rust.
      • pindakaas - cadical)[:package:](https://crates.io/crates/pindakaas-derive)[:package:](https://crates.io/crates/pindakaas-intel-sat)[:package:](https://crates.io/crates/pindakaas-kissat)[:package:](https://crates.io/crates/pyndakaas) - transform integer and pseudo Boolean constraints into conjunctive normal form.
      • rsmaxsat - bindings for [EvalMaxSAT ](https://github.com/FlorentAvellaneda/EvalMaxSAT).
      • Espresso Logic Minimizer - logic)[:package:](https://crates.io/crates/espresso-logic-macros) - bindings to the [Espresso](https://ptolemy.berkeley.edu/projects/embedded/pubs/downloads/espresso/index.htm) heuristic logic minimiser from UC Berkeley.
      • CNFGEN 2 - newer version of CNFGEN - DIMACS CNF generator.
      • smt-str - str) - data structures and utilities to parse, manipulate, and reason about [SMT-LIB strings](https://smt-lib.org/theories-UnicodeStrings.shtml).
      • Joker Calculus - implementation of Joker Calculus in Rust.
      • program-induction - library for program induction and learning representations.
      • vampire-rs - prover)[:package:](https://crates.io/crates/vampire-sys) - safe Rust bindings to the [Vampire](https://vprover.github.io/) theorem prover for first-order logic with equality.
      • Yaspar - a parser for the [SMT-LIB 2.7](https://smt-lib.org/index.shtml) language generated by the [LARLPOP](https://github.com/lalrpop/lalrpop) parser generator.
      • Logician - type-safe SMT solver driver.
      • sat-interface - interface) - abstraction interface for SAT solvers.
      • sat-solvers - solvers) - unified Rust interface to multiple SAT solvers with automatic source compilation.
      • Yaspar-IR - ir) - provides a few representations of SMT scripts and other functionalities.
      • Leo3 - ffi)[:package:](https://crates.io/crates/leo3-macros)[:package:](crates.io/crates/leo3-build-config) - safe, ergonomic Rust bindings to the [Lean4](https://github.com/leanprover/lean4) theorem prover, inspired by [PyO3](https://github.com/PyO3/pyo3)'s architecture..
      • cvc5-rs - rs)[:package:](https://crates.io/crates/cvc5-sys) - safe, high-level Rust bindings for the [cvc5](https://cvc5.github.io/) SMT solver.
      • xmt-lib - lib) - grounder for SMT solvers.
      • logic-form - form):baby_chick: - library for representing Cube, Clause, CNF and DNF.
      • 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).

    • Provers and Solvers

      • ~~cobalt~~ - a wip minimal proof assistant.
      • Proost - simple proof assistant.
      • meancop - became CoP.
      • lazyCoP - automatic theorem prover for first-order logic with equality.
      • lerna - proves theorems.
      • lickety - prototype system for linear resolution with splitting.
      • Serkr - automated theorem prover for first order logic with equality.
Programming Languages
Rust 348 C 4 SMT 4 Python 2 OCaml 1 HTML 1 Gnuplot 1 Jupyter Notebook 1 C++ 1 Linear Programming 1
Categories
Resources 343 Projects 315 Programming Language 31 Propositional logic 24 Unclassified 21 Lambda Calculus 16 Books code 12 Kanren 5 About ## 2
Sub Categories
Community 288 Libraries 236 Provers and Solvers 112 Verification 76 Crates keywords 20 Posts 11 Research Paper & Thesis 11 Blogs 8 Demos 4 Books 1
Keywords
rust 76 sat-solver 29 sat 15 verification 12 dependent-types 12 formal-verification 10 parser 10 logic 10 lambda-calculus 10 type-theory 9 programming-language 9 optimization 7 theorem-proving 7 theorem-prover 7 rust-lang 7 satisfiability 6 linear-programming 6 compiler 6 logic-programming 6 solver 5 language 5 proof-assistant 5 smt 5 interpreter 4 type-system 4 functional-programming 4 formal-methods 4 wasm 4 cdcl 4 math 4 rust-bindings 4 rust-library 3 minisat 3 category-theory 3 dsl 3 repl 3 dependent-record-types 3 term-rewriting 3 program-induction 3 learning 3 lambda-calculus-interpreter 3 proof-checker 3 hindley-milner 3 smt-solver 3 cnf 3 types 3 z3 3 refinement-types 3 unsat 3 static-analyzer 3