gbrochar
/
ready_set_boole
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'negation_normal_form'

This commit is contained in:
gbrochar 2024-01-24 13:31:30 +01:00
parent b01b184e46 dea2e2d6a3
commit 76a3f12d9e
13 changed files with 491 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/adder.rs
View File

@ -12,4 +12,3 @@ pub fn adder(a: u32, b: u32) -> u32 {
}
result
}

323
src/ast.rs
View File

@ -1,20 +1,24 @@
mod tests;
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Token {
Negation,
Conjunction,
Disjunction,
ExclusiveDisjunction,
MaterialCondition,
LogicalEquivalence
LogicalEquivalence,
}
#[derive(Debug, Clone)]
pub enum Node<T> {
#[derive(Debug, Clone, PartialEq)]
pub enum Node<T>
where
T: Clone + std::fmt::Debug,
{
Leaf(T),
Unary {
operator: Token,
operand: Box<Node<T>>
operand: Box<Node<T>>,
},
Binary {
operator: Token,
@ -23,7 +27,285 @@ pub enum Node<T> {
},
}
pub fn add_unary_node<T>(stack: &mut Vec<Node<T>>, token: Token) {
impl<T> Node<T>
where
T: Clone + std::fmt::Debug,
{
fn negation_conjunction_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
Node::Binary {
operator: Token::Disjunction,
lhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*lhs.clone()),
}),
rhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*rhs.clone()),
}),
}
}
fn negation_disjunction_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*lhs.clone()),
}),
rhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*rhs.clone()),
}),
}
}
fn negation_material_condition_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(*lhs.clone()),
rhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*rhs.clone()),
}),
}
}
fn material_condition_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
Node::Binary {
operator: Token::Disjunction,
lhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*lhs.clone()),
}),
rhs: Box::new(*rhs.clone()),
}
}
fn negation_exclusive_disjunction_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
Node::Binary {
operator: Token::Disjunction,
lhs: Box::new(Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*lhs.clone()),
}),
rhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*rhs.clone()),
}),
}),
rhs: Box::new(Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(*lhs.clone()),
rhs: Box::new(*rhs.clone()),
}),
}
}
fn exclusive_disjunction_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(Node::Binary {
operator: Token::Disjunction,
lhs: Box::new(*lhs.clone()),
rhs: Box::new(*rhs.clone()),
}),
rhs: Box::new(Node::Binary {
operator: Token::Disjunction,
lhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*lhs.clone()),
}),
rhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*rhs.clone()),
}),
}),
}
}
fn logical_equivalence_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(Node::Binary {
operator: Token::Disjunction,
lhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*lhs.clone()),
}),
rhs: Box::new(*rhs.clone()),
}),
rhs: Box::new(Node::Binary {
operator: Token::Disjunction,
lhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*rhs.clone()),
}),
rhs: Box::new(*lhs.clone()),
}),
}
}
fn negation_logical_equivalence_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
Node::Binary {
operator: Token::Disjunction,
lhs: Box::new(Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(*lhs.clone()),
rhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*rhs.clone()),
}),
}),
rhs: Box::new(Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(*rhs.clone()),
rhs: Box::new(Node::Unary {
operator: Token::Negation,
operand: Box::new(*lhs.clone()),
}),
}),
}
}
pub fn simplify(&mut self) {
match self {
Node::Unary { operator, operand } if *operator == Token::Negation => match &**operand {
Node::Unary {
operator: inner_op,
operand: inner_operand,
} if *inner_op == Token::Negation => {
*self = *inner_operand.clone();
self.simplify();
}
Node::Binary {
operator: inner_op,
lhs: inner_lhs,
rhs: inner_rhs,
} => {
*self = match *inner_op {
Token::Conjunction => {
Self::negation_conjunction_to_nnf(inner_lhs, inner_rhs)
}
Token::Disjunction => {
Self::negation_disjunction_to_nnf(inner_lhs, inner_rhs)
}
Token::ExclusiveDisjunction => {
Self::negation_exclusive_disjunction_to_nnf(inner_lhs, inner_rhs)
}
Token::LogicalEquivalence => {
Self::negation_logical_equivalence_to_nnf(inner_lhs, inner_rhs)
}
Token::MaterialCondition => {
Self::negation_material_condition_to_nnf(inner_lhs, inner_rhs)
}
_ => unreachable!(),
};
self.simplify();
}
_ => (),
},
Node::Binary {
operator, lhs, rhs, ..
} => {
if let Some(node) = match *operator {
Token::ExclusiveDisjunction => {
Some(Self::exclusive_disjunction_to_nnf(lhs, rhs))
}
Token::LogicalEquivalence => Some(Self::logical_equivalence_to_nnf(lhs, rhs)),
Token::MaterialCondition => Some(Self::material_condition_to_nnf(lhs, rhs)),
_ => None,
} {
*self = node.clone();
self.simplify();
} else {
lhs.simplify();
rhs.simplify();
}
}
_ => (),
}
}
}
impl Node<bool> {
pub fn parse_formula(formula: &str) -> Node<bool> {
let mut stack = vec![];
for c in formula.chars() {
match c {
'0' => stack.push(Node::Leaf(false)),
'1' => stack.push(Node::Leaf(true)),
'!' => add_unary_node(&mut stack, Token::Negation),
'&' => add_binary_node(&mut stack, Token::Conjunction),
'|' => add_binary_node(&mut stack, Token::Disjunction),
'^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction),
'>' => add_binary_node(&mut stack, Token::MaterialCondition),
'=' => add_binary_node(&mut stack, Token::LogicalEquivalence),
_ => panic!("Error: {} is not a valid character", c),
}
}
stack.pop().unwrap()
}
pub fn ast_to_formula(ast: &Node<bool>) -> String {
let mut str = String::from("");
match ast {
Node::Unary { operator, operand } => {
str.push_str(Self::ast_to_formula(operand).as_str());
str.push(token_to_char(*operator));
}
Node::Binary { operator, lhs, rhs } => {
str.push_str(Self::ast_to_formula(lhs).as_str());
str.push_str(Self::ast_to_formula(rhs).as_str());
str.push(token_to_char(*operator));
}
Node::Leaf(b) => str.push(bool_to_char(*b)),
};
str
}
}
impl Node<char> {
pub fn parse_formula(formula: &str) -> Node<char> {
let mut stack = vec![];
for c in formula.chars() {
match c {
'A'..='Z' => stack.push(Node::Leaf(c)),
'!' => add_unary_node(&mut stack, Token::Negation),
'&' => add_binary_node(&mut stack, Token::Conjunction),
'|' => add_binary_node(&mut stack, Token::Disjunction),
'^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction),
'>' => add_binary_node(&mut stack, Token::MaterialCondition),
'=' => add_binary_node(&mut stack, Token::LogicalEquivalence),
_ => panic!("Error: {} is not a valid character", c),
}
}
stack.pop().unwrap()
}
pub fn ast_to_formula(ast: &Node<char>) -> String {
let mut str = String::from("");
match ast {
Node::Unary { operator, operand } => {
str.push_str(Self::ast_to_formula(operand).as_str());
str.push(token_to_char(*operator));
}
Node::Binary { operator, lhs, rhs } => {
str.push_str(Self::ast_to_formula(lhs).as_str());
str.push_str(Self::ast_to_formula(rhs).as_str());
str.push(token_to_char(*operator));
}
Node::Leaf(c) => str.push(*c),
};
str
}
}
pub fn add_unary_node<T>(stack: &mut Vec<Node<T>>, token: Token)
where
T: Clone + std::fmt::Debug,
{
let operand = Box::new(stack.pop().unwrap());
stack.push(Node::Unary {
operator: token,
@ -31,12 +313,33 @@ pub fn add_unary_node<T>(stack: &mut Vec<Node<T>>, token: Token) {
});
}
pub fn add_binary_node<T>(stack: &mut Vec<Node<T>>, token: Token) {
let lhs = Box::new(stack.pop().unwrap());
pub fn add_binary_node<T>(stack: &mut Vec<Node<T>>, token: Token)
where
T: Clone + std::fmt::Debug,
{
let rhs = Box::new(stack.pop().unwrap());
let lhs = Box::new(stack.pop().unwrap());
stack.push(Node::Binary {
operator: token,
lhs,
rhs
rhs,
});
}
}
fn bool_to_char(b: bool) -> char {
match b {
false => '0',
true => '1',
}
}
fn token_to_char(token: Token) -> char {
match token {
Token::Negation => '!',
Token::Conjunction => '&',
Token::Disjunction => '|',
Token::ExclusiveDisjunction => '^',
Token::MaterialCondition => '>',
Token::LogicalEquivalence => '=',
}
}

69
src/ast/tests.rs
View File

@ -1,13 +1,74 @@
#[cfg(test)]
mod tests {
use crate::ast::{add_binary_node, Node, Token};
#[test]
fn add_nodes() {
let stack = vec![Node::Leaf(true), Node::Leaf(false)];
let mut stack = vec![Node::Leaf(true), Node::Leaf(false)];
let rhs = vec![Node::Binary {
operator: Token::Conjunction,
lhs: Box::new(Node::Leaf(true)),
rhs: Box::new(Node::Leaf(false))
rhs: Box::new(Node::Leaf(false)),
}];
assert_eq!(add_binary_node(&mut stack, Token::Conjunction), rhs);
add_binary_node(&mut stack, Token::Conjunction);
assert_eq!(stack, rhs);
}
}
#[test]
fn ast_to_formula_bool() {
let formula = "01&";
assert_eq!(
Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
formula
);
let formula = "01&00|&";
assert_eq!(
Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
formula
);
let formula = "01&00|&11^&";
assert_eq!(
Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
formula
);
let formula = "01&00|&11=^";
assert_eq!(
Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
formula
);
let formula = "01&00|&0!=";
assert_eq!(
Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
formula
);
}
#[test]
fn ast_to_formula_char() {
let formula = "AB&";
assert_eq!(
Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
formula
);
let formula = "AB&CD|&";
assert_eq!(
Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
formula
);
let formula = "AB&AC|&DE^&";
assert_eq!(
Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
formula
);
let formula = "AB&CD|&EF=^";
assert_eq!(
Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
formula
);
let formula = "AB&CD|&E!=";
assert_eq!(
Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
formula
);
}
}

28
src/boolean_evaluation.rs
View File

@ -1,24 +1,6 @@
mod tests;
use crate::ast::{ Token, Node, add_unary_node, add_binary_node };
fn parse_formula(formula: &str) -> Node<bool> {
let mut stack = vec![];
for c in formula.chars() {
match c {
'0' => stack.push(Node::Leaf(false)),
'1' => stack.push(Node::Leaf(true)),
'!' => add_unary_node(&mut stack, Token::Negation),
'&' => add_binary_node(&mut stack, Token::Conjunction),
'|' => add_binary_node(&mut stack, Token::Disjunction),
'^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction),
'>' => add_binary_node(&mut stack, Token::MaterialCondition),
'=' => add_binary_node(&mut stack, Token::LogicalEquivalence),
_ => panic!("Error: {} is not a valid character", c)
}
}
stack.pop().unwrap()
}
use crate::ast::{Node, Token};
fn compute(operator: Token, lhs: bool, rhs: bool) -> bool {
match operator {
@ -27,7 +9,7 @@ fn compute(operator: Token, lhs: bool, rhs: bool) -> bool {
Token::Disjunction => lhs | rhs,
Token::ExclusiveDisjunction => lhs ^ rhs,
Token::MaterialCondition => !(lhs && !rhs),
Token::LogicalEquivalence => lhs == rhs
Token::LogicalEquivalence => lhs == rhs,
}
}
@ -39,7 +21,7 @@ fn evaluate(tree: Node<bool>) -> bool {
}
}
fn eval_formula(formula: &str) -> bool {
let tree = parse_formula(formula);
pub fn eval_formula(formula: &str) -> bool {
let tree = Node::<bool>::parse_formula(formula);
evaluate(tree)
}
}

7
src/boolean_evaluation/tests.rs
View File

@ -15,7 +15,6 @@ mod tests {
fn only_unary() {
assert_eq!(eval_formula("1!"), false);
assert_eq!(eval_formula("0!"), true);
}
#[test]
@ -23,8 +22,10 @@ mod tests {
assert_eq!(eval_formula("1!!"), true);
assert_eq!(eval_formula("0!!"), false);
assert_eq!(eval_formula("0!!!"), true);
assert_eq!(eval_formula("1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"), true);
assert_eq!(
eval_formula("1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"),
true
);
}
#[test]

1
src/gray_code.rs
View File

@ -10,4 +10,3 @@ pub fn gray_code(n: u32) -> u32 {
}
result
}

2
src/gray_code/tests.rs
View File

@ -20,6 +20,6 @@ mod tests {
fn msb_u32() {
assert_eq!(gray_code(3_000_000_000), 3_954_733_312);
assert_eq!(gray_code(2_147_483_648), 3_221_225_472);
assert_eq!(gray_code(4_294_967_295), 2_147_483_648);
assert_eq!(gray_code(4_294_967_295), 2_147_483_648);
}
}

10
src/main.rs
View File

@ -1,9 +1,10 @@
mod adder;
mod multiplier;
mod gray_code;
mod boolean_evaluation;
mod truth_table;
mod ast;
mod boolean_evaluation;
mod gray_code;
mod multiplier;
mod negation_normal_form;
mod truth_table;
use gray_code::gray_code;
use truth_table::print_truth_table;
@ -20,4 +21,5 @@ fn main() {
println!("{}", gray_code(7));
println!("{}", gray_code(3));
print_truth_table("ZFG|&");
print_truth_table("ABC|&");
}

2
src/multiplier.rs
View File

@ -4,7 +4,7 @@ use crate::adder::adder;
pub fn multiplier(a: u32, b: u32) -> u32 {
let mut result = 0;
for i in 0..32 {
if a >> i & 1 == 1 {
result = adder(result, b << i);

9
src/negation_normal_form.rs Normal file
View File

@ -0,0 +1,9 @@
mod tests;
use crate::ast::Node;
fn negation_normal_form(formula: &str) -> String {
let mut ast = Node::<char>::parse_formula(formula);
ast.simplify();
Node::<char>::ast_to_formula(&ast)
}

68
src/negation_normal_form/tests.rs Normal file
View File

@ -0,0 +1,68 @@
#[cfg(test)]
mod tests {
use crate::negation_normal_form::negation_normal_form;
#[test]
fn double_neg_simple() {
assert_eq!(negation_normal_form("A!!"), "A");
assert_eq!(negation_normal_form("B!!!!"), "B");
assert_eq!(negation_normal_form("C!!!"), "C!");
assert_eq!(negation_normal_form("D!!!!!!!!!!!!!!!!"), "D");
assert_eq!(negation_normal_form("E!!!!!!!!!!!!!!!"), "E!");
}
#[test]
fn double_neg() {
assert_eq!(negation_normal_form("A!!Z&"), "AZ&");
assert_eq!(negation_normal_form("B!!Z!!&"), "BZ&");
assert_eq!(negation_normal_form("C!!Z!&"), "CZ!&");
assert_eq!(negation_normal_form("D!!Z&!!!!"), "DZ&");
assert_eq!(negation_normal_form("E!!Z!!!!&!!"), "EZ&");
assert_eq!(negation_normal_form("F!!Z!&!!!!!!!!"), "FZ!&");
}
#[test]
fn neg_and() {
assert_eq!(negation_normal_form("AZ&!"), "A!Z!|");
assert_eq!(negation_normal_form("BZ&!BZ&!&"), "B!Z!|B!Z!|&");
assert_eq!(negation_normal_form("CZ&!CZ&!&!"), "CZ&CZ&|");
}
#[test]
fn neg_or() {
assert_eq!(negation_normal_form("AZ|!"), "A!Z!&");
assert_eq!(negation_normal_form("BZ|!BZ|!|"), "B!Z!&B!Z!&|");
assert_eq!(negation_normal_form("CZ|!CZ|!|!"), "CZ|CZ|&");
}
#[test]
fn material_condition() {
assert_eq!(negation_normal_form("AZ>"), "A!Z|");
assert_eq!(negation_normal_form("BZ>!"), "BZ!&");
}
#[test]
fn exclusive_disjunction() {
assert_eq!(negation_normal_form("AZ^"), "AZ|A!Z!|&");
assert_eq!(negation_normal_form("BZ^!"), "B!Z!&BZ&|");
}
#[test]
fn logical_equivalence() {
assert_eq!(negation_normal_form("AZ="), "A!Z|Z!A|&");
assert_eq!(negation_normal_form("BZ=!"), "BZ!&ZB!&|");
}
#[test]
fn subject_tests() {
assert_eq!(negation_normal_form("AB&!"), "A!B!|");
assert_eq!(negation_normal_form("AB|!"), "A!B!&");
assert_eq!(negation_normal_form("AB>"), "A!B|");
assert_eq!(negation_normal_form("AB|C&!"), "A!B!&C!|");
}
#[test]
fn complex_tests() {
assert_eq!("A", "A");
}
}

26
src/truth_table.rs
View File

@ -1,7 +1,7 @@
mod tests;
use crate::ast::{add_binary_node, add_unary_node, Node, Token};
use std::collections::HashSet;
use crate::ast::{ Token, Node, add_unary_node, add_binary_node };
fn parse_formula(formula: &str) -> Node<bool> {
let mut stack = vec![];
@ -15,7 +15,7 @@ fn parse_formula(formula: &str) -> Node<bool> {
'^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction),
'>' => add_binary_node(&mut stack, Token::MaterialCondition),
'=' => add_binary_node(&mut stack, Token::LogicalEquivalence),
_ => panic!("Error: {} is not a valid character", c)
_ => panic!("Error: {} is not a valid character", c),
}
}
stack.pop().unwrap()
@ -28,7 +28,7 @@ fn compute(operator: Token, lhs: bool, rhs: bool) -> bool {
Token::Disjunction => lhs | rhs,
Token::ExclusiveDisjunction => lhs ^ rhs,
Token::MaterialCondition => !(lhs && !rhs),
Token::LogicalEquivalence => lhs == rhs
Token::LogicalEquivalence => lhs == rhs,
}
}
@ -45,7 +45,9 @@ fn get_hashset(formula: &str) -> HashSet<char> {
for c in formula.chars() {
match c {
'A'..='Z' => { hashset.insert(c); },
'A'..='Z' => {
hashset.insert(c);
}
'!' | '&' | '|' | '^' | '>' | '=' => (),
_ => panic!("Error: {} is not a valid character", c),
}
@ -61,8 +63,16 @@ fn eval_formula(formula: &str) -> bool {
fn recursive_fn(formula: &str, mut vec: Vec<char>, format: String) {
let char = vec.pop();
if let Some(c) = char {
recursive_fn(formula.replace(c, "0").as_str(), vec.clone(), format!("{format} 0 |"));
recursive_fn(formula.replace(c, "1").as_str(), vec.clone(), format!("{format} 1 |"));
recursive_fn(
formula.replace(c, "0").as_str(),
vec.clone(),
format!("{format} 0 |"),
);
recursive_fn(
formula.replace(c, "1").as_str(),
vec.clone(),
format!("{format} 1 |"),
);
} else {
match eval_formula(formula) {
false => println!("{format} 0 |"),
@ -88,5 +98,5 @@ pub fn print_truth_table(formula: &str) {
println!("{format}");
println!("{separator}");
recursive_fn(formula, vec.into_iter().rev().collect(), String::from("|"));
// call eval formula a lot
}
// call eval formula a lot
}

2
src/truth_table/tests.rs
View File

@ -23,6 +23,6 @@ mod tests {
#[test]
fn big() {
print_truth_table("AB&CD&&EF&GH&&&IJ&KL&&MN&OP&&&QR&ST&&UV&WX&&&YZ&&&")
//print_truth_table("AB&CD&&EF&GH&&&IJ&KL&&MN&OP&&&QR&ST&&UV&WX&&&YZ&&&")
}
}