https://github.com/matszpk/cnfgen

The library to generate CNF (Conjunctive Normal Form) formulaes.
https://github.com/matszpk/cnfgen

Last synced: about 1 month ago
JSON representation

The library to generate CNF (Conjunctive Normal Form) formulaes.

• Host: GitHub
• URL: https://github.com/matszpk/cnfgen
• Owner: matszpk
• License: lgpl-2.1
• Created: 2022-10-15T09:20:04.000Z (over 1 year ago)
• Default Branch: master
• Last Pushed: 2024-05-04T10:12:56.000Z (about 2 months ago)
• Last Synced: 2024-05-05T10:17:46.233Z (about 2 months ago)
• Language: Rust
• Size: 462 KB
• Stars: 1
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: COPYING

Lists

• awesome-rust-formalized-reasoning - CNFGEN - create boolean formulae from boolean expressions and integer expressions. (Projects / Libraries)

README

        
# CNFGEN

The library to generate CNF (Conjunctive Normal Form) formula.

This library provides simple CNF writer, structures to create boolean formula from

boolean expressions and integer expressions. The module `writer` provides

basic types, traits to handle clauses and literals, simple the CNF writer to write

same CNF formulas. The `boolexpr` module provides structure to construct boolean

expressions. The `intexpr` and `dynintexpr` modules provides structure and traits to

construct integer expressions.

Same construction of expressions can be done in natural way by using operators or

methods. The object called `ExprCreator` holds all expressions. The main structures

that allow construct expressions are expression nodes: `BoolExprNode`, `IntExprNode`

and `DynIntExprNode`. BoolExprNode allow to construct boolean expressions.

`IntExprNode` and `DynIntExprNode` allow to construct integer expressions or multiple

bit expressions.

Typical usage of this library is: construction boolean expression and write it by using

method `write` from an expression object. The `writer` module can be used to write

'raw' CNF formulas that can be generated by other software.

Sample usage:

```

use cnfgen::boolexpr::*;

use cnfgen::intexpr::*;

use cnfgen::writer::{CNFError, CNFWriter};

use std::io;

fn write_diophantine_equation() -> Result<(), CNFError> {

    // define ExprCreator.

    let creator = ExprCreator32::new();

    // define variables - signed 32-bit wide.

    let x = I32ExprNode::variable(creator.clone());

    let y = I32ExprNode::variable(creator.clone());

    let z = I32ExprNode::variable(creator.clone());

    // define equation: x^2 + y^2 - 77*z^2 = 0

    let powx = x.clone().fullmul(x);  // x^2

    let powy = y.clone().fullmul(y);  // y^2

    let powz = z.clone().fullmul(z);  // z^2

    // We use cond_mul to get product and required condition to avoid overflow.

    let (prod, cond0) = powz.cond_mul(77i64);

    // Similary, we use conditional addition and conditional subtraction.

    let (sum1, cond1) = powx.cond_add(powy);

    let (diff2, cond2) = sum1.cond_sub(prod);

    // define final formula with required conditions.

    let formula: BoolExprNode<_> = diff2.equal(0) & cond0 & cond1 & cond2;

    // write CNF to stdout.

    formula.write(&mut CNFWriter::new(io::stdout()))

}

```