Skip to content

Network Model

bayescalc.network_model

This module defines the core data structures for the Bayesian Network.

Classes

Variable dataclass

Represents a random variable.

Source code in src/bayescalc/network_model.py 
 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
@dataclass(frozen=True)
class Variable:
    """Represents a random variable."""

    name: str
    domain: Tuple[str, ...]

    def __repr__(self):
        return f"Variable({self.name}, {self.domain})"

    @property
    def is_boolean(self) -> bool:
        """Returns True if this is a boolean variable (domain includes True/False or T/F)."""
        if len(self.domain) != 2:
            return False

        # Check for various boolean representations
        true_values = {"True", "T"}
        false_values = {"False", "F"}

        has_true = any(val in true_values for val in self.domain)
        has_false = any(val in false_values for val in self.domain)

        return has_true and has_false

    @property
    def var_type(self) -> str:
        """Returns the type of the variable as a string: 'Boolean' or 'Multival'."""
        return "Boolean" if self.is_boolean else "Multival"
Attributes
is_boolean property

Returns True if this is a boolean variable (domain includes True/False or T/F).

var_type property

Returns the type of the variable as a string: 'Boolean' or 'Multival'.

Factor dataclass

Represents a factor (e.g., a CPT) in the network.

Source code in src/bayescalc/network_model.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
@dataclass
class Factor:
    """Represents a factor (e.g., a CPT) in the network."""

    variables: Tuple[Variable, ...]
    probabilities: Dict[Tuple[str, ...], float] = field(default_factory=dict)
    name: str | None = None

    def __repr__(self):
        if self.name:
            # For single probability results, we want a clean output
            if not self.variables and len(self.probabilities) == 1:
                prob = list(self.probabilities.values())[0]
                return f"{self.name} = {prob:.4f}"
            return self.name
        return f"Factor({[v.name for v in self.variables]})"

BayesianNetwork

Represents a Bayesian Network.

Source code in src/bayescalc/network_model.py 
 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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
class BayesianNetwork:
    """Represents a Bayesian Network."""

    def __init__(self):
        self.variables: Dict[str, Variable] = {}
        self.variable_order: List[str] = []
        self.factors: Dict[str, Factor] = {}
        self.adj: Dict[str, Set[str]] = {}
        self.rev_adj: Dict[str, Set[str]] = {}

    def add_variable(self, name: str, domain: Tuple[str, ...]):
        """Adds a variable to the network."""
        if name in self.variables:
            raise ValueError(f"Variable '{name}' already exists.")
        self.variables[name] = Variable(name, domain)
        self.variable_order.append(name)
        self.adj[name] = set()
        self.rev_adj[name] = set()

    def add_factor(
        self,
        variable_name: str,
        parent_names: List[str],
        cpt_entries: Dict[Tuple[str, ...], float],
    ):
        """Adds a factor (CPT) to the network."""
        if variable_name not in self.variables:
            raise ValueError(f"Variable '{variable_name}' not found.")

        variable = self.variables[variable_name]
        parents = [self.variables[p] for p in parent_names]

        factor_variables = (variable,) + tuple(parents)
        factor = Factor(factor_variables)

        # Validate and auto-complete CPT
        self._validate_and_complete_cpt(factor, cpt_entries, variable, parents)

        self.factors[variable_name] = factor

        for p in parent_names:
            self.adj[p].add(variable_name)
            self.rev_adj[variable_name].add(p)

    def _validate_and_complete_cpt(
        self,
        factor: Factor,
        cpt_entries: Dict[Tuple[str, ...], float],
        variable: Variable,
        parents: List[Variable],
    ):
        """Validates and auto-completes the CPT entries."""
        if not parents:
            # Prior probability
            total_prob = 0.0
            for val in variable.domain:
                if (val,) in cpt_entries:
                    total_prob += cpt_entries[(val,)]
                    factor.probabilities[(val,)] = cpt_entries[(val,)]

            if len(cpt_entries) < len(variable.domain):
                # Auto-complete
                if len(variable.domain) - len(cpt_entries) == 1:
                    missing_val = [
                        v for v in variable.domain if (v,) not in cpt_entries
                    ][0]
                    factor.probabilities[(missing_val,)] = 1.0 - total_prob
                else:
                    raise ValueError(
                        f"Ambiguous auto-completion for '{variable.name}'. Please specify more entries."
                    )

            if abs(sum(factor.probabilities.values()) - 1.0) > 1e-6:
                raise ValueError(
                    f"Probabilities for '{variable.name}' do not sum to 1."
                )
        else:
            # Conditional probability
            parent_domains = [p.domain for p in parents]
            from itertools import product

            parent_combinations = list(product(*parent_domains))

            for p_comb in parent_combinations:
                total_prob = 0.0

                for val in variable.domain:
                    key = (val,) + p_comb
                    if key in cpt_entries:
                        total_prob += cpt_entries[key]
                        factor.probabilities[key] = cpt_entries[key]

                if len([k for k in cpt_entries if k[1:] == p_comb]) < len(
                    variable.domain
                ):
                    # Auto-complete
                    if (
                        len(variable.domain)
                        - len([k for k in cpt_entries if k[1:] == p_comb])
                        == 1
                    ):
                        missing_val = [
                            v
                            for v in variable.domain
                            if (v,) + p_comb not in cpt_entries
                        ][0]
                        factor.probabilities[(missing_val,) + p_comb] = 1.0 - total_prob
                    else:
                        raise ValueError(
                            f"Ambiguous auto-completion for '{variable.name}' given {p_comb}. Please specify more entries."
                        )

                if (
                    abs(
                        sum(
                            factor.probabilities[(v,) + p_comb] for v in variable.domain
                        )
                        - 1.0
                    )
                    > 1e-6
                ):
                    raise ValueError(
                        f"Probabilities for '{variable.name}' given {p_comb} do not sum to 1."
                    )

    def get_parents(self, variable_name: str) -> Set[str]:
        """Returns the parents of a variable."""
        return self.rev_adj.get(variable_name, set())

    def get_children(self, variable_name: str) -> Set[str]:
        """Returns the children of a variable."""
        return self.adj.get(variable_name, set())

    def __repr__(self):
        return f"BayesianNetwork(variables={list(self.variables.keys())})"
Functions
add_variable(name, domain)

Adds a variable to the network.

Source code in src/bayescalc/network_model.py 
68
69
70
71
72
73
74
75
def add_variable(self, name: str, domain: Tuple[str, ...]):
    """Adds a variable to the network."""
    if name in self.variables:
        raise ValueError(f"Variable '{name}' already exists.")
    self.variables[name] = Variable(name, domain)
    self.variable_order.append(name)
    self.adj[name] = set()
    self.rev_adj[name] = set()
add_factor(variable_name, parent_names, cpt_entries)

Adds a factor (CPT) to the network.

Source code in src/bayescalc/network_model.py 
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def add_factor(
    self,
    variable_name: str,
    parent_names: List[str],
    cpt_entries: Dict[Tuple[str, ...], float],
):
    """Adds a factor (CPT) to the network."""
    if variable_name not in self.variables:
        raise ValueError(f"Variable '{variable_name}' not found.")

    variable = self.variables[variable_name]
    parents = [self.variables[p] for p in parent_names]

    factor_variables = (variable,) + tuple(parents)
    factor = Factor(factor_variables)

    # Validate and auto-complete CPT
    self._validate_and_complete_cpt(factor, cpt_entries, variable, parents)

    self.factors[variable_name] = factor

    for p in parent_names:
        self.adj[p].add(variable_name)
        self.rev_adj[variable_name].add(p)
get_parents(variable_name)

Returns the parents of a variable.

Source code in src/bayescalc/network_model.py 
183
184
185
def get_parents(self, variable_name: str) -> Set[str]:
    """Returns the parents of a variable."""
    return self.rev_adj.get(variable_name, set())
get_children(variable_name)

Returns the children of a variable.

Source code in src/bayescalc/network_model.py 
187
188
189
def get_children(self, variable_name: str) -> Set[str]:
    """Returns the children of a variable."""
    return self.adj.get(variable_name, set())