Struct ProofNode 

pub struct ProofNode {
    pub goal: String,
    pub rule_name: Option<String>,
    pub bindings: HashMap<String, String>,
    pub children: Vec<ProofNode>,
    pub depth: usize,
    pub proven: bool,
    pub node_type: ProofNodeType,
}

Represents a single node in the proof tree

Fields

goal: String

The goal that was proven at this node

rule_name: Option<String>

Name of the rule that was used (if any)

bindings: HashMap<String, String>

Variable bindings at this node

children: Vec<ProofNode>

Child nodes (sub-goals that were proven)

depth: usize

Depth in the proof tree

proven: bool

Whether this goal was proven successfully

node_type: ProofNodeType

Type of proof node

Implementations

impl ProofNode

pub fn new(goal: String, depth: usize) -> Self

Create a new proof node

pub fn fact(goal: String, depth: usize) -> Self

Create a fact node

pub fn rule(goal: String, rule_name: String, depth: usize) -> Self

Create a rule node

pub fn negation(goal: String, depth: usize, proven: bool) -> Self

Create a negation node

pub fn add_child(&mut self, child: ProofNode)

Add a child node

pub fn set_bindings(&mut self, bindings: &Bindings)

Set bindings from Bindings object

pub fn set_bindings_map(&mut self, bindings: HashMap<String, String>)

Set bindings from HashMap

pub fn is_leaf(&self) -> bool

Check if this is a leaf node

pub fn print_tree(&self, indent: usize)

Print the proof tree

pub fn height(&self) -> usize

Get tree height

pub fn node_count(&self) -> usize

Count total nodes

Trait Implementations

impl Clone for ProofNode

fn clone(&self) -> ProofNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProofNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProofNode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ProofNode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.