https://github.com/jsfpdn/sdd-rs
Bottom-up sentential decision diagram compiler.
https://github.com/jsfpdn/sdd-rs
decision-diagram knowledge-compilation model-counting model-enumeration satisfiability-problem sdd sentential-decision-diagram
Last synced: 10 months ago
JSON representation
Bottom-up sentential decision diagram compiler.
- Host: GitHub
- URL: https://github.com/jsfpdn/sdd-rs
- Owner: jsfpdn
- Created: 2024-02-03T09:53:51.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2024-11-24T22:55:35.000Z (over 1 year ago)
- Last Synced: 2024-11-24T23:28:03.847Z (over 1 year ago)
- Topics: decision-diagram, knowledge-compilation, model-counting, model-enumeration, satisfiability-problem, sdd, sentential-decision-diagram
- Language: Rust
- Homepage:
- Size: 353 KB
- Stars: 4
- Watchers: 1
- Forks: 0
- Open Issues: 11
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# :books: sddrs: Bottom-Up Sentential Decision Diagram Compiler
**Incrementally build, manipualate, and optimize
[Sentential Decision Diagrams (SDD)](https://en.wikipedia.org/wiki/Sentential_decision_diagram):
a succinct representation of Boolean functions.**
Crate's API documentation can be found [here](https://docs.rs/sddrs/latest/sddrs/).
## :tada: Features
The compiler currently supports:
* incremental compilation of Boolean functions (knowledge bases) to *compressed* and *trimmed* SDDs,
* efficient querying of model count, model enumeration, and equivalence of SDDs,
* dynamic minimization of SDDs via *vtree fragments*,
* garbage collection of dead nodes,
* SDD compilation from CNF in
[DIMACS](https://www21.in.tum.de/~lammich/2015_SS_Seminar_SAT/resources/dimacs-cnf.pdf) format.
## Usage
### :package: Library
To use the compiler within a project, add the following line to your Cargo.toml:
```toml
[dependencies]
sddrs = { version = "0.1" }
```
Then import the crate, initialize an `SddManager` and compile Boolean functions!
The following snippet compiles the function $(A \land B) \lor C$ to an SDD,
computes number of its models, enumerates and prints them to the stdout,
and renders the compiled SDD and its vtree to the DOT format.
```rust
use sddrs::manager::{options, GCStatistics, SddManager};
use sddrs::literal::literal::Polarity;
use bon::arr;
fn main() {
let options = options::SddOptions::builder()
// Create right-linear vtree.
.vtree_strategy(options::VTreeStragey::RightLinear)
// Initialize the manager with variables A, B, and C.
.variables(["A".to_string(), "B".to_string(), "C"])
.build();
let manager = SddManager::new(options);
// Retrieve SDDs for literals A, B, and C.
let a = manager.literal("A", Polarity::Positive).unwrap();
let b = manager.literal("B", Polarity::Positive).unwrap();
let c = manager.literal("C", Polarity::Positive).unwrap();
// Compute "A ∧ B"
let a_and_b = manager.conjoin(&a, &b);
// Compute "(A ∧ B) ∨ C"
let a_and_b_or_c = manager.disjoin(&a_and_b, &c);
let model_count = manager.model_count(&a_and_b_or_c);
let models = manager.model_enumeration(&a_and_b_or_c);
println!("'(A ∧ B) ∨ C' has {model_count} models.");
println!("They are:\n{models}");
let sdd_path = "my_formula.dot"
let f = File::create(sdd_path).unwrap();
let mut b = BufWriter::new(f);
manager
.draw_sdd(&mut b as &mut dyn std::io::Write, &sdd)
.unwrap();
let vtree_path = "my_vtree.dot"
let f = File::create(vtree_path).unwrap();
let mut b = BufWriter::new(f);
manager
.draw_vtree(&mut b as &mut dyn std::io::Write)
.unwrap();
println!("Rendered SDD to '{sdd_path}' and vtree to '{vtree_path}'");
}
```
**See [examples](https://github.com/jsfpdn/sdd-rs/tree/main/sddrs/examples) for more examples.**
### Binary
The compiler can be also compiled and invoked as a command-line utility.
```sh
cargo build --release
./target/release/sddrsc \
--count-models \
--enumerate-models \
--vtree right-linear \
--minimize-after-k-clauses 2 \
--print-statistics \
--collect-garbage \
--sdd.dot \
--dimacs-path ./static/datasets/easy.cnf
```
To render the SDD, install [Graphviz](https://graphviz.org/) and run
```sh
dot sdd.dot -Tpng -o sdd.png
```
## :page_with_curl: Related Links
* [SDD: A New Canonical Representation of Propositional Knowledge Bases - Adnad Darwiche](http://reasoning.cs.ucla.edu/fetch.php?id=121&type=pdf):
paper introducing SDDs
* [Dynamic Minimization of Sentential Decision Diagrams - Arthur Choi and Adnan Darwiche](http://reasoning.cs.ucla.edu/fetch.php?id=128&type=pdf):
paper describing dynamic minimization of SDDs
* [SDD: A New Canonical Representation of Propositional Knowledge Bases – Adnan Darwiche (YouTube tutorial)](https://www.youtube.com/watch?v=_5Estmve91o)
* [Bottom-Up Knowledge Compilers – Adnan Darwiche (YouTube tutorial)](https://www.youtube.com/watch?v=8yZapazT9Ls)
* [The SDD Package homepage](http://reasoning.cs.ucla.edu/sdd/): homepage of the original C SDD compiler
* [RSDD](https://github.com/neuppl/rsdd): alternative implementation of SDD in Rust