use num_bigint::BigInt;
use std::collections::HashMap;
use std::fmt;
use crate::constants::UsefulConstants;
use super::ir::VariableName;
#[derive(Clone)]
pub struct ValueEnvironment {
constants: UsefulConstants,
reduces_to: HashMap<VariableName, ValueReduction>,
}
impl ValueEnvironment {
pub fn new(constants: &UsefulConstants) -> ValueEnvironment {
ValueEnvironment { constants: constants.clone(), reduces_to: HashMap::new() }
}
pub fn add_variable(&mut self, name: &VariableName, value: &ValueReduction) -> bool {
if let Some(previous) = self.reduces_to.insert(name.clone(), value.clone()) {
assert_eq!(previous, *value);
false
} else {
true
}
}
#[must_use]
pub fn get_variable(&self, name: &VariableName) -> Option<&ValueReduction> {
self.reduces_to.get(name)
}
pub fn prime(&self) -> &BigInt {
self.constants.prime()
}
}
pub trait ValueMeta {
fn propagate_values(&mut self, env: &mut ValueEnvironment) -> bool;
#[must_use]
fn is_constant(&self) -> bool;
#[must_use]
fn is_boolean(&self) -> bool;
#[must_use]
fn is_field_element(&self) -> bool;
#[must_use]
fn value(&self) -> Option<&ValueReduction>;
}
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum ValueReduction {
Boolean { value: bool },
FieldElement { value: BigInt },
}
impl fmt::Display for ValueReduction {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
use ValueReduction::*;
match self {
Boolean { value } => write!(f, "{value}"),
FieldElement { value } => write!(f, "{value}"),
}
}
}
#[derive(Default, Clone)]
pub struct ValueKnowledge {
reduces_to: Option<ValueReduction>,
}
impl ValueKnowledge {
#[must_use]
pub fn new() -> ValueKnowledge {
ValueKnowledge::default()
}
#[must_use]
pub fn set_reduces_to(&mut self, reduces_to: ValueReduction) -> bool {
let result = self.reduces_to.is_none();
self.reduces_to = Some(reduces_to);
result
}
#[must_use]
pub fn get_reduces_to(&self) -> Option<&ValueReduction> {
self.reduces_to.as_ref()
}
#[must_use]
pub fn is_constant(&self) -> bool {
self.reduces_to.is_some()
}
#[must_use]
pub fn is_boolean(&self) -> bool {
use ValueReduction::*;
matches!(self.reduces_to, Some(Boolean { .. }))
}
#[must_use]
pub fn is_field_element(&self) -> bool {
use ValueReduction::*;
matches!(self.reduces_to, Some(FieldElement { .. }))
}
}
#[cfg(test)]
mod tests {
use num_bigint::BigInt;
use crate::ir::value_meta::ValueReduction;
use super::ValueKnowledge;
#[test]
fn test_value_knowledge() {
let mut value = ValueKnowledge::new();
assert!(matches!(value.get_reduces_to(), None));
let number = ValueReduction::FieldElement { value: BigInt::from(1) };
assert!(value.set_reduces_to(number));
assert!(matches!(value.get_reduces_to(), Some(ValueReduction::FieldElement { .. })));
assert!(value.is_field_element());
assert!(!value.is_boolean());
let boolean = ValueReduction::Boolean { value: true };
assert!(!value.set_reduces_to(boolean));
assert!(matches!(value.get_reduces_to(), Some(ValueReduction::Boolean { .. })));
assert!(!value.is_field_element());
assert!(value.is_boolean());
}
}