xlog-prob 0.9.2

Probabilistic inference engines for XLOG
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Evidence forcing for Monte Carlo sampling.

use xlog_core::{Result, XlogError};

use super::{McProgram, McSamplingMethod};

/// Why evidence may or may not be forceable to root Bernoulli variables.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ForceabilityReason {
    AllForceable,
    ContainsDerivedEvidence,
    ContainsNegativeAdHeadEvidence,
    NoEvidence,
}

/// Compiled evidence forcing for the MC sampler.
#[derive(Debug, Clone)]
pub struct EvidenceForcing {
    pub force_mask: Vec<u8>,
    pub forced_value: Vec<u8>,
    pub forceable: bool,
    pub reason: ForceabilityReason,
}

impl McProgram {
    /// Resolve the sampling method from config + evidence forceability.
    pub(super) fn resolve_sampling_method(
        &self,
        requested: Option<McSamplingMethod>,
    ) -> Result<(McSamplingMethod, EvidenceForcing)> {
        let forcing = self.compile_evidence_forcing()?;
        let method = match requested {
            Some(McSamplingMethod::EvidenceClamping) => {
                if !forcing.forceable {
                    return Err(XlogError::Execution(format!(
                        "Cannot use EvidenceClamping: {:?}",
                        forcing.reason
                    )));
                }
                McSamplingMethod::EvidenceClamping
            }
            Some(McSamplingMethod::Rejection) => McSamplingMethod::Rejection,
            None => {
                if forcing.forceable {
                    McSamplingMethod::EvidenceClamping
                } else {
                    McSamplingMethod::Rejection
                }
            }
        };
        Ok((method, forcing))
    }

    pub fn compile_evidence_forcing(&self) -> Result<EvidenceForcing> {
        let num_vars = self.bernoulli_probs.len();
        let mut force_mask = vec![0u8; num_vars];
        let mut forced_value = vec![0u8; num_vars];

        if self.evidence.is_empty() {
            return Ok(EvidenceForcing {
                force_mask,
                forced_value,
                forceable: false,
                reason: ForceabilityReason::NoEvidence,
            });
        }

        for (atom, expected) in &self.evidence {
            // Try to match against prob fact specs
            if let Some(spec) = self.prob_facts.iter().find(|s| &s.atom == atom) {
                force_mask[spec.var_idx] = 1;
                forced_value[spec.var_idx] = if *expected { 1 } else { 0 };
                continue;
            }

            // Try to match against AD choice atoms (positive evidence only)
            let mut found_ad = false;
            for ad in &self.annotated_disjunctions {
                if let Some(choice_idx) = ad.choices.iter().position(|c| c == atom) {
                    if !*expected {
                        // evidence(ad_head, false) — not forceable in v0.5.1
                        return Ok(EvidenceForcing {
                            force_mask: vec![0u8; num_vars],
                            forced_value: vec![0u8; num_vars],
                            forceable: false,
                            reason: ForceabilityReason::ContainsNegativeAdHeadEvidence,
                        });
                    }

                    let num_decision_vars = ad.decision_vars.len();
                    if choice_idx < num_decision_vars {
                        // Force d_i = 0 for all i < choice_idx, d_{choice_idx} = 1
                        for i in 0..choice_idx {
                            force_mask[ad.decision_vars[i]] = 1;
                            forced_value[ad.decision_vars[i]] = 0;
                        }
                        force_mask[ad.decision_vars[choice_idx]] = 1;
                        forced_value[ad.decision_vars[choice_idx]] = 1;
                    } else {
                        // Last head (no none branch): force all decision vars to 0
                        for &dv in &ad.decision_vars {
                            force_mask[dv] = 1;
                            forced_value[dv] = 0;
                        }
                    }
                    found_ad = true;
                    break;
                }
            }
            if found_ad {
                continue;
            }

            // Evidence atom not found in prob facts or AD choices → derived/deterministic
            return Ok(EvidenceForcing {
                force_mask: vec![0u8; num_vars],
                forced_value: vec![0u8; num_vars],
                forceable: false,
                reason: ForceabilityReason::ContainsDerivedEvidence,
            });
        }

        Ok(EvidenceForcing {
            force_mask,
            forced_value,
            forceable: true,
            reason: ForceabilityReason::AllForceable,
        })
    }
}