Enum biodivine_lib_param_bn::FnUpdate

pub enum FnUpdate {
    Const(bool),
    Var(VariableId),
    Param(ParameterId, Vec<VariableId>),
    Not(Box<FnUpdate>),
    Binary(BinaryOp, Box<FnUpdate>, Box<FnUpdate>),
}

A Boolean update function formula which references Variables and Parameters of a BooleanNetwork.

An update function specifies the evolution rules for one specific Variable of a BooleanNetwork. The arguments used in the function must be the same as specified by the RegulatoryGraph of the network.

Variants

Const(bool)

A true/false constant.

Var(VariableId)

References a network variable.

Param(ParameterId, Vec<VariableId>)

References a network parameter (uninterpreted function).

The variable list are the arguments of the function invocation.

Not(Box<FnUpdate>)

Negation.

Binary(BinaryOp, Box<FnUpdate>, Box<FnUpdate>)

Binary boolean operation.

Implementations

impl FnUpdate

pub(crate) fn symbolic_eval_true(
    &self,
    state: IdState,
    encoder: &BddParameterEncoder
) -> BddParams

(internal) Evaluate this FnUpdate into symbolic BddParams that represent all parameter valuations for which this function evaluates to true.

pub(super) fn _symbolic_eval(
    &self,
    state: IdState,
    encoder: &BddParameterEncoder
) -> Bdd

impl FnUpdate

pub fn try_from_expression(
    expression: BooleanExpression,
    graph: &RegulatoryGraph
) -> Option<FnUpdate>

Convert a BooleanExpression to a FnUpdate, using RegulatoryGraph to resolve variable names.

impl FnUpdate

Constructor and destructor utility methods. These mainly avoid unnecessary boxing and exhaustive pattern matching when not necessary.

pub fn mk_true() -> FnUpdate

Create a true formula.

pub fn mk_false() -> FnUpdate

Create a false formula.

pub fn mk_var(id: VariableId) -> FnUpdate

Create an x formula where x is a Boolean variable.

pub fn mk_param(id: ParameterId, args: &[VariableId]) -> FnUpdate

Create a p(x_1, ..., x_k) formula where p is a parameter function and x_1 through x_k are its arguments.

pub fn mk_not(inner: FnUpdate) -> FnUpdate

Create a !phi formula, where phi is an inner FnUpdate.

pub fn mk_binary(op: BinaryOp, left: FnUpdate, right: FnUpdate) -> FnUpdate

Create a phi 'op' psi where phi and psi are arguments of op operator.

pub fn negation(self) -> FnUpdate

Negate this function.

pub fn and(self, other: FnUpdate) -> FnUpdate

Create a conjunction.

pub fn or(self, other: FnUpdate) -> FnUpdate

Create a disjunction.

pub fn xor(self, other: FnUpdate) -> FnUpdate

Create an exclusive or.

pub fn implies(self, other: FnUpdate) -> FnUpdate

Create an implication.

pub fn iff(self, other: FnUpdate) -> FnUpdate

Create an equivalence.

pub fn as_const(&self) -> Option<bool>

If Const, return the value, otherwise return None.

pub fn as_var(&self) -> Option<VariableId>

If Var, return the id, otherwise return None.

pub fn as_param(&self) -> Option<(ParameterId, &[VariableId])>

If Param, return the id and args, otherwise return None.

pub fn as_not(&self) -> Option<&FnUpdate>

If Not, return the inner function, otherwise return None.

pub fn as_binary(&self) -> Option<(&FnUpdate, BinaryOp, &FnUpdate)>

If Binary, return the operator and left/right formulas, otherwise return None.

impl FnUpdate

Other utility methods.

pub fn collect_arguments(&self) -> Vec<VariableId>

Return a sorted vector of all variables that are actually used as inputs in this function.

pub fn collect_parameters(&self) -> Vec<ParameterId>

Return a sorted vector of all parameters (i.e. uninterpreted functions) that are used in this update function.

pub fn to_string(&self, context: &BooleanNetwork) -> String

Convert this update function to a string, taking names from the provided BooleanNetwork.

pub fn evaluate(&self, values: &HashMap<VariableId, bool>) -> Option<bool>

If possible, evaluate this function using the given network variable valuation.

Note that this only works when the function output does not depend on parameters, and all necessary variable values are part of the valuation. Otherwise, the function returns None, as the value cannot be determined.

However, note that in some cases, even a partially specified function can be evaluated. For example, A & f(X, Y) is false whenever A = false, regardless of uninterpreted function f. In such cases, this method may still output the correct result.

In other words, the meaning of this method should be interpreted as “if it is possible to unambiguously evaluate this function using the provided valuation, do it; otherwise return None”.

pub fn is_specialisation_of(&self, other: &FnUpdate) -> bool

Test that this update function is a syntactic specialisation of the provided FnUpdate.

Syntactic specialisation is a function that has the same abstract syntax tree, except that some occurrences of parameters can be substituted for more concrete Boolean functions.

Note that this is not entirely bulletproof, as it does not check for usage of multiple parameters within the same function, which could influence the semantics of the main function, but does not influence the specialisation.

pub fn walk_postorder<F>(&self, action: &mut F) where
    F: FnMut(&FnUpdate), 

Allows us to iterate through all nodes of the abstract syntax tree of this function in post-order.

Note that this is a preliminary version of the API. A more robust implementation should provide a standard iterator interface.

pub fn substitute(
    &self,
    vars: &[VariableId],
    params: &[ParameterId]
) -> FnUpdate

Create a copy of this function which replaces every occurrence of every VariableId with a new one supplied by the provided vector (original VariableId is the index into the vector). Similarly replaces every ParameterId.

Trait Implementations

impl Clone for FnUpdate

fn clone(&self) -> FnUpdate

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FnUpdate

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for FnUpdate

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<FnUpdate> for FnUpdate

fn eq(&self, other: &FnUpdate) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &FnUpdate) -> bool

This method tests for !=.

impl Eq for FnUpdate

impl StructuralEq for FnUpdate

impl StructuralPartialEq for FnUpdate