compiled-knowledge 4.0.0a15__cp312-cp312-win_amd64.whl → 4.0.0a17__cp312-cp312-win_amd64.whl

ck/circuit_compiler/cython_vm_compiler/_compiler.pyx

@@ -1,17 +1,15 @@
 from __future__ import annotations
 
-from pickletools import long1
-from typing import Sequence, Dict, List, Tuple, Set, Optional, Iterator
+from typing import Dict, Tuple, Sequence
 
 import numpy as np
 import ctypes as ct
 
 from ck import circuit
-from ck.circuit import CircuitNode, ConstNode, VarNode, OpNode, ADD, Circuit
+from ck.circuit import OpNode, VarNode, CircuitNode
 from ck.circuit_compiler.support.circuit_analyser import CircuitAnalysis, analyze_circuit
-from ck.circuit_compiler.support.input_vars import infer_input_vars, InputVars
-from ck.program.raw_program import RawProgram, RawProgramFunction
-from ck.utils.np_extras import DType, NDArrayNumeric, NDArray, DTypeNumeric
+from ck.program.raw_program import RawProgramFunction
+from ck.utils.np_extras import NDArrayNumeric, DTypeNumeric
 
 from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free
 
@@ -63,21 +61,21 @@ def make_function(
 
 
 # VM instructions
-ADD = circuit.ADD
-MUL = circuit.MUL
-COPY: int = max(ADD, MUL) + 1
+cdef int ADD = circuit.ADD
+cdef int MUL = circuit.MUL
+cdef int COPY = max(ADD, MUL) + 1
 
 # VM arrays
-VARS: int = 0
-TMPS: int = 1
-CONSTS: int = 2
-RESULT: int = 3
+cdef int VARS = 0
+cdef int TMPS = 1
+cdef int CONSTS = 2
+cdef int RESULT = 3
 
 
-def _make_instructions_from_analysis(
-        analysis: CircuitAnalysis,
-        dtype: DTypeNumeric,
-) -> Tuple[Instructions, NDArrayNumeric]:
+cdef tuple[Instructions, cnp.ndarray] _make_instructions_from_analysis(
+        object analysis: CircuitAnalysis,
+        object dtype: DTypeNumeric,
+): # -> Tuple[Instructions, NDArrayNumeric]:
     if dtype != np.float64:
         raise RuntimeError(f'only DType {np.float64} currently supported')
 
@@ -91,7 +89,7 @@ def _make_instructions_from_analysis(
         np_consts[i] = node.value
 
     # Where to get input values for each possible node.
-    node_to_element: Dict[int, ElementID] = {}
+    cdef dict[int, ElementID] node_to_element  = {}
     # const nodes
     for node_id, const_idx in node_to_const_idx.items():
         node_to_element[node_id] = ElementID(CONSTS, const_idx)
@@ -110,21 +108,16 @@ def _make_instructions_from_analysis(
     # Build instructions
     instructions: Instructions = Instructions()
 
-    op_node: OpNode
+    cdef object op_node
     for op_node in analysis.op_nodes:
-        dest: ElementID = node_to_element[id(op_node)]
-        args: list[ElementID] = [
-            node_to_element[id(arg)]
-            for arg in op_node.args
-        ]
-        instructions.append(op_node.symbol, args, dest)
+        instructions.append_op(op_node.symbol, op_node, node_to_element)
 
     # Add any copy operations, i.e., result nodes that are not op nodes
     for i, node in enumerate(analysis.result_nodes):
         if not isinstance(node, OpNode):
             dest: ElementID = ElementID(RESULT, i)
-            args: list[ElementID] = [node_to_element[id(node)]]
-            instructions.append(COPY, args, dest)
+            src: ElementID = node_to_element[id(node)]
+            instructions.append_copy(src, dest)
 
     return instructions, np_consts
 
@@ -143,32 +136,63 @@ cdef struct Instruction:
 
 cdef class Instructions:
     cdef Instruction* instructions
+    cdef int allocated
     cdef int num_instructions
 
-    def __init__(self):
-        self.instructions = <Instruction*> PyMem_Malloc(0)
+    def __init__(self) -> None:
         self.num_instructions = 0
+        self.allocated = 64
+        self.instructions = <Instruction*> PyMem_Malloc(self.allocated * sizeof(Instruction))
+
+    cdef void append_copy(
+            self,
+            ElementID src,
+            ElementID dest,
+    ) except*:
+        c_args = <ElementID*> PyMem_Malloc(sizeof(ElementID))
+        if not c_args:
+            raise MemoryError()
 
-    def append(self, int symbol, list[ElementID] args, ElementID dest) -> None:
+        c_args[0] = src
+        self._append(COPY, 1, c_args, dest)
+
+    cdef void append_op(self, int symbol, object op_node: OpNode, dict[int, ElementID] node_to_element) except*:
+        args = op_node.args
         cdef int num_args = len(args)
-        cdef int i
 
-        c_args = <ElementID*> PyMem_Malloc(
-            num_args * sizeof(ElementID))
+        # Create the instruction arguments array
+        c_args = <ElementID*> PyMem_Malloc(num_args * sizeof(ElementID))
         if not c_args:
             raise MemoryError()
 
-        for i in range(num_args):
-            c_args[i] = args[i]
+        cdef int i = num_args
+        while i > 0:
+            i -= 1
+            c_args[i] = node_to_element[id(args[i])]
+
+        dest: ElementID = node_to_element[id(op_node)]
+
+        self._append(symbol, num_args, c_args, dest)
+
+
+    cdef void _append(self, int symbol, int num_args, ElementID* c_args, ElementID dest) except *:
+        cdef int i
 
         cdef int num_instructions = self.num_instructions
-        self.instructions = <Instruction*> PyMem_Realloc(
-            self.instructions,
-            sizeof(Instruction) * (num_instructions + 1)
-        )
-        if not self.instructions:
-            raise MemoryError()
 
+        # Ensure sufficient instruction memory
+        cdef int allocated = self.allocated
+        if num_instructions == allocated:
+            allocated *= 2
+            self.instructions = <Instruction*> PyMem_Realloc(
+                self.instructions,
+                allocated * sizeof(Instruction),
+            )
+            if not self.instructions:
+                raise MemoryError()
+            self.allocated = allocated
+
+        # Add the instruction
         self.instructions[num_instructions] = Instruction(
             symbol,
             num_args,
@@ -177,7 +201,7 @@ cdef class Instructions:
         )
         self.num_instructions = num_instructions + 1
 
-    def __dealloc__(self):
+    def __dealloc__(self) -> None:
         cdef Instruction* instructions = self.instructions
         if instructions:
             for i in range(self.num_instructions):
@@ -194,15 +218,15 @@ cdef void cvm_float64(
     double* consts,
     double* result,
     Instructions instructions,
-):
-    # Core virtual machine.
+) except *:
+    # Core virtual machine (for dtype float64).
 
-    cdef int i, num_args, symbol
+    cdef int i, symbol
     cdef double accumulator
     cdef ElementID* args
-    cdef ElementID elem
+    cdef ElementID  elem
 
-    # index the four arrays by constants VARS, TMPS, CONSTS, and RESULT
+    # Index the four arrays by constants VARS, TMPS, CONSTS, and RESULT
     cdef (double*) arrays[4]
     arrays[VARS] = vars_in
     arrays[TMPS] = tmps
@@ -210,29 +234,32 @@ cdef void cvm_float64(
     arrays[RESULT] = result
 
     cdef Instruction* instruction_ptr = instructions.instructions
-    for _ in range(instructions.num_instructions):
+    cdef int num_instructions = instructions.num_instructions
 
-        symbol = instruction_ptr[0].symbol
-        args = instruction_ptr[0].args
-        num_args = instruction_ptr[0].num_args
+    while num_instructions > 0:
+        num_instructions -= 1
+
+        symbol = instruction_ptr.symbol
+        args = instruction_ptr.args
 
         elem = args[0]
         accumulator = arrays[elem.array][elem.index]
 
         if symbol == ADD:
-            for i in range(1, num_args):
+            i = instruction_ptr.num_args
+            while i > 1:
+                i -= 1
                 elem = args[i]
                 accumulator += arrays[elem.array][elem.index]
         elif symbol == MUL:
-            for i in range(1, num_args):
+            i = instruction_ptr.num_args
+            while i > 1:
+                i -= 1
                 elem = args[i]
                 accumulator *= arrays[elem.array][elem.index]
-        elif symbol == COPY:
-            pass
-        else:
-            raise RuntimeError('symbol not understood: ' + str(symbol))
+        # else symbol == COPY, nothing to do
 
-        elem = instruction_ptr[0].dest
+        elem = instruction_ptr.dest
         arrays[elem.array][elem.index] = accumulator
 
         # Advance the instruction pointer

ck/circuit_compiler/named_circuit_compilers.py

@@ -54,4 +54,4 @@ class NamedCircuitCompiler(Enum):
         return self.value[0]
 
 
-DEFAULT_CIRCUIT_COMPILER: NamedCircuitCompiler = NamedCircuitCompiler.LLVM_VM
+DEFAULT_CIRCUIT_COMPILER: NamedCircuitCompiler = NamedCircuitCompiler.CYTHON_VM

ck/in_out/parse_ace_nnf.py

@@ -1,11 +1,12 @@
 from abc import ABC, abstractmethod
-from typing import Tuple, Optional, Dict, List
+from typing import Tuple, Optional, Dict, List, Sequence
 
 import numpy as np
 
 from ck.circuit import Circuit, CircuitNode, VarNode, ConstValue, ConstNode
 from ck.in_out.parse_ace_lmap import LiteralMap
 from ck.in_out.parser_utils import ParseError, ParserInput
+from ck.pgm import Indicator
 from ck.pgm_circuit.slot_map import SlotKey, SlotMap
 from ck.utils.np_extras import NDArrayFloat64
 
@@ -18,9 +19,9 @@ def read_nnf_with_literal_map(
         input_stream,
         literal_map: LiteralMap,
         *,
+        indicators: Sequence[Indicator] = (),
         const_parameters: bool = True,
         optimise_ops: bool = True,
-        circuit: Optional[Circuit] = None,
         check_header: bool = False,
 ) -> Tuple[CircuitNode, SlotMap, NDArrayFloat64]:
     """
@@ -31,8 +32,8 @@ def read_nnf_with_literal_map(
 
     Args:
         input_stream: to parse, as per `ParserInput` argument.
+        indicators: any indicators to pre allocate to circuit variables.
         literal_map: mapping from literal code to indicators.
-        circuit: an optional circuit to reuse.
         check_header: if true, an exception is raised if the number of nodes or arcs is not as expected.
         const_parameters: if true, the potential function parameters will be circuit
             constants, otherwise they will be circuit variables.
@@ -44,6 +45,7 @@ def read_nnf_with_literal_map(
         slot_map: is a map from indicator to a circuit var index (int).
         params: is a numpy array of parameter values, co-indexed with `circuit.vars[num_indicators:]`
     """
+    circuit = Circuit()
 
     # Set the `const_literals` parameter for `read_nnf`
     const_literals: Optional[Dict[int, ConstValue]]
@@ -57,38 +59,42 @@ def read_nnf_with_literal_map(
     else:
         const_literals = {}
 
-    top_node, literal_slot_map = read_nnf(
+    # Make a slot map to map from an indicator to a circuit variable index.
+    # Preload `var_literals` to map literal codes to circuit vars.
+    # We allocate the circuit variables here to ensure that indicators
+    # come before parameters in the circuit variables.
+    slot_map: Dict[SlotKey, int] = {
+        indicator: i
+        for i, indicator in enumerate(indicators)
+    }
+    circuit.new_vars(len(slot_map))
+    var_literals: Dict[int, int] = {}
+    for literal_code, indicator in literal_map.indicators.items():
+        slot = slot_map.get(indicator)
+        if slot is None:
+            slot = circuit.new_var().idx
+            slot_map[indicator] = slot
+        var_literals[literal_code] = slot
+    num_indicators: int = len(slot_map)
+
+    # Parse the nnf file
+    top_node, vars_literals = read_nnf(
         input_stream,
+        var_literals=var_literals,
         const_literals=const_literals,
         circuit=circuit,
         check_header=check_header,
         optimise_ops=optimise_ops,
     )
-    circuit = top_node.circuit
-
-    # Build the slot map from indicator to slot.
-    # Some indicators may not be in `literal_slot_map` because they were not needed
-    # for the arithmetic circuit in the NNF file. For those indicators, we create
-    # dummy circuit vars.
-    def _get_slot(_literal_code: int) -> int:
-        _slot: Optional[int] = literal_slot_map.get(_literal_code)
-        if _slot is None:
-            _slot: int = circuit.new_var().idx
-        return _slot
 
-    slot_map: Dict[SlotKey, int] = {
-        indicator: _get_slot(literal_code)
-        for literal_code, indicator in literal_map.indicators.items()
-    }
-
-    # Get the parameter values
-    num_indicators: int = len(literal_map.indicators)
+    # Get the parameter values.
+    # Any new circuit vars added to the circuit are parameters.
+    # Parameter IDs are not added to the slot map as we don't know them.
     num_parameters: int = top_node.circuit.number_of_vars - num_indicators
     assert num_parameters == 0 or not const_parameters, 'const_parameters -> num_parameters == 0'
-
     params: NDArrayFloat64 = np.zeros(num_parameters, dtype=np.float64)
     for literal_code, value in literal_map.params.items():
-        literal_slot: Optional[int] = literal_slot_map.get(literal_code)
+        literal_slot: Optional[int] = var_literals.get(literal_code)
         if literal_slot is not None and literal_slot >= num_indicators:
             params[literal_slot - num_indicators] = value
 
@@ -98,6 +104,7 @@ def read_nnf_with_literal_map(
 def read_nnf(
         input_stream,
         *,
+        var_literals: Optional[Dict[int, int]] = None,
         const_literals: Optional[Dict[int, ConstValue]] = None,
         circuit: Optional[Circuit] = None,
         check_header: bool = False,
@@ -109,44 +116,51 @@ def read_nnf(
     The input consists of propositional logical sentences in negative normal form (NNF).
     This covers both ".ac" and ".nnf" files produced by the software ACE.
 
-    The returned slot map will have entries to get circuit vars for literal codes.
-    E.g., given a literal code (int), use `circuit.vars[slot_map[literal_code]]` to get its var node.
+    This function returns the last node parsed (or the constant zero node if no nodes passed).
+    It also returns a mapping from literal code (int) to circuit variable index.
 
-    Software may simplify an NNF file by removing arcs, but it may not update the header.
-    Although the resulting file is not conformant, it is still parsable.
-    Parameter `check_header` can be set to false, which prevents an exception being raised.
+    Two optional dictionaries may be supplied. Dictionary `var_literals` maps a literal
+    code to a pre-existing circuit variable index. Dictionary `const_literals` maps a literal
+    code to a constant value. A literal code should not appear in both dictionaries.
+
+    Any literal code that is parsed but does not appear in `var_literals` or `const_literals`
+    results in a new circuit variable being created and a corresponding entry added to
+    `var_literals`.
+
+    External software may modify an NNF file by removing arcs, but it may not update the header.
+    Although the resulting file is not conformant, it is still parsable (by ignoring the header).
+    Parameter `check_header` can be set to true, which causes an exception being raised if the
+    header disagrees with the rest of the file.
 
     Args:
         input_stream: to parse, as per `ParserInput` argument.
+        var_literals: an optional mapping from literal code to existing circuit variable index.
         const_literals: an optional mapping from literal code to constant value.
         circuit: an optional empty circuit to reuse.
         check_header: if true, an exception is raised if the number of nodes or arcs is not as expected.
         optimise_ops: if true then circuit optimised operations will be used.
 
     Returns:
-        (circuit_top, literal_slot_map)
+        (circuit_top, var_literals)
         circuit_top: is the resulting top node from parsing the input.
-        literal_slot_map: is a mapping from literal code (int) to a circuit var index (int).
-
-    Assumes:
-        If a circuit is provided, it is empty.
+        var_literals: is a mapping from literal code (int) to a circuit variable index (int).
     """
     if circuit is None:
         circuit: Circuit = Circuit()
 
-    if circuit.number_of_vars != 0:
-        raise ValueError('the given circuit must be empty')
+    if var_literals is None:
+        var_literals: Dict[int, int] = {}
 
     if const_literals is None:
         const_literals: Dict[int, ConstValue] = {}
 
-    parser = CircuitParser(circuit, check_header, const_literals, optimise_ops)
+    parser = CircuitParser(circuit, check_header, var_literals, const_literals, optimise_ops)
     parser.parse(input_stream)
 
     nodes = parser.nodes
     cct_top = circuit.zero if len(nodes) == 0 else nodes[-1]
 
-    return cct_top, parser.literal_slot_map
+    return cct_top, var_literals
 
 
 class Parser(ABC):
@@ -198,6 +212,8 @@ class Parser(ABC):
                                     self.add_node(raise_f, args)
                                 else:
                                     self.mul_node(raise_f, args)
+                    else:
+                        raise_f(f'unexpected parser state: {state}')
                 line = input_stream.readline()
             self.done(raise_f)
         except ParseError as e:
@@ -236,17 +252,18 @@ class CircuitParser(Parser):
             self,
             circuit: Circuit,
             check_header: bool,
+            var_literals: Dict[int, int],
             const_literals: Dict[int, ConstValue],
             optimise_ops: bool,
     ):
         self.check_header: bool = check_header
-        self.literal_slot_map: Dict[SlotKey, int] = {}
-        self.optimise_ops = optimise_ops
-        self.circuit = circuit
+        self.var_literals: Dict[int, int] = var_literals
         self.const_literals: Dict[int, ConstValue] = const_literals
+        self.optimise_ops: bool = optimise_ops
+        self.circuit: Circuit = circuit
         self.nodes: List[CircuitNode] = []
-        self.num_nodes = None
-        self.num_edges = None
+        self.num_nodes = None  # read from the file header for checking
+        self.num_edges = None  # read from the file header for checking
 
     def comment(self, raise_f, message: str) -> None:
         pass
@@ -257,13 +274,20 @@ class CircuitParser(Parser):
         """
         const_value: Optional[ConstValue] = self.const_literals.get(literal_code)
         if const_value is not None:
+            # Literal code maps to a constant value
+            if literal_code in self.var_literals:
+                raise_f('literal code both constant and variable: {literal_code}')
             node: ConstNode = self.circuit.const(const_value)
-        elif literal_code in self.literal_slot_map.keys():
-            raise_f(f'duplicated literal code: {literal_code}')
-            return
+
+        elif (var_idx := self.var_literals.get(literal_code)) is not None:
+            # Literal code maps to an existing circuit variable
+            node: VarNode = self.circuit.vars[var_idx]
+
         else:
+            # Literal code maps to a new circuit variable
             node: VarNode = self.circuit.new_var()
-            self.literal_slot_map[literal_code] = node.idx
+            self.var_literals[literal_code] = node.idx
+
         self.nodes.append(node)
 
     def add_node(self, raise_f, args: List[int]) -> None:

ck/in_out/parser_utils.py

@@ -32,7 +32,7 @@ class ParserInput:
     def __init__(self, input_stream):
         self._input = _check_input(input_stream)
         self._prev_line_len = 0
-        self._cur_line = 1
+        self._cur_line = 0
         self._cur_char = 1
         self._lookahead = []
 

ck/pgm_compiler/ace/ace.py

@@ -14,6 +14,7 @@ from ck.in_out.render_net import render_bayesian_network
 from ck.pgm import PGM
 from ck.pgm_circuit import PGMCircuit
 from ck.pgm_circuit.slot_map import SlotMap
+from ck.utils.local_config import config
 from ck.utils.np_extras import NDArrayFloat64
 from ck.utils.tmp_dir import tmp_dir
 
@@ -121,8 +122,9 @@ def compile_pgm(
             parameter_values: NDArrayFloat64
             circuit_top, slot_map, parameter_values = read_nnf_with_literal_map(
                 file,
+                indicators=pgm.indicators,
                 literal_map=literal_map,
-                const_parameters=const_parameters
+                const_parameters=const_parameters,
             )
 
     # Consistency checking
@@ -198,8 +200,12 @@ def copy_ace_to_default_location(
 def default_ace_location() -> Path:
     """
     Get the default location for Ace files.
+
+    This function checks the local config for the variable
+    CK_ACE_LOCATION. If that is not available, then the
+    directory that this Python module is in will be used.
     """
-    return Path(__file__).parent
+    return Path(config.get('CK_ACE_LOCATION', Path(__file__).parent))
 
 
 @dataclass

ck/pgm_compiler/factor_elimination.py

@@ -149,7 +149,7 @@ def join_tree_to_circuit(
         limit_product_tree_search,
     )
     top: CircuitNode = top_table.top()
-    top_table.circuit.remove_unreachable_op_nodes(top)
+    top.circuit.remove_unreachable_op_nodes(top)
 
     return PGMCircuit(
         rvs=tuple(pgm.rvs),
@@ -169,27 +169,37 @@ def _circuit_tables_from_join_tree(
 ) -> CircuitTable:
     """
     This is a basic algorithm for constructing a circuit table from a join tree.
+    Algorithm synopsis:
+    1) Get a CircuitTable for each factor allocated to this join tree node, and
+       for each child of the join tree node (recursive call to _circuit_tables_from_join_tree).
+    2) Form a binary tree of the collected circuit tables.
+    3) Perform table products and sum-outs for each node in the binary tree, which should
+       leave a single circuit table with a single row.
     """
-    # The PGM factors allocated to this join tree node
-    factors: List[CircuitTable] = [
-        factor_tables.get_table(factor)
-        for factor in join_tree.factors
-    ]
-
-    # The children of this join tree node
-    factors.extend(
-        _circuit_tables_from_join_tree(factor_tables, child, limit_product_tree_search)
-        for child in join_tree.children
+    # Get all the factors to combine.
+    factors: List[CircuitTable] = list(
+        chain(
+            (
+                # The PGM factors allocated to this join tree node
+                factor_tables.get_table(factor)
+                for factor in join_tree.factors
+            ),
+            (
+                # The children of this join tree node
+                _circuit_tables_from_join_tree(factor_tables, child, limit_product_tree_search)
+                for child in join_tree.children
+            ),
+        )
     )
 
     # The usual join tree approach just forms the product all the tables in `factors`.
     # The tree width is not affected by the order of products, however some orders
     # lead to smaller numbers of arithmetic operations.
     #
-    # If `options.optimise_products` is true, then heuristics are used
+    # If `limit_product_tree_search > 1`, then heuristics are used
     # reduce the number of arithmetic operations.
 
-    # Deal with the special case: no factors
+    # Deal with the special case: zero factors
     if len(factors) == 0:
         circuit = factor_tables.circuit
         if len(join_tree.separator) == 0:

ck/pgm_compiler/support/circuit_table/__init__.py

@@ -1,5 +1,5 @@
-# from .circuit_table_py import (
-from .circuit_table import (
+# from ._circuit_table_py import (
+from ._circuit_table_cy import (
     CircuitTable,
     TableInstance,
     sum_out,

ck/pgm_compiler/support/circuit_table/{circuit_table.pyx → _circuit_table_cy.pyx}

@@ -142,7 +142,7 @@ cpdef object sum_out(object table: CircuitTable, object rv_idxs: Iterable[int]):
 
     for group_instance_tuple, to_add in groups.items():
         node = circuit.optimised_add(to_add)
-        if not node.is_zero():
+        if not node.is_zero:
             rows[group_instance_tuple] = node
 
     return new_table
@@ -159,7 +159,7 @@ cpdef object sum_out_all(object table: CircuitTable):  # -> CircuitTable:
         node = next(iter(table.rows.values()))
     else:
         node: CircuitNode = circuit.optimised_add(table.rows.values())
-        if node.is_zero():
+        if node.is_zero:
             return CircuitTable(circuit, ())
 
     return CircuitTable(circuit, (), [((), node)])
@@ -190,7 +190,7 @@ cpdef object product(x: CircuitTable, y: CircuitTable):  # -> CircuitTable:
 
     # Special case: y == 0 or 1, and has no random variables.
     if len(y.rv_idxs) == 0:
-        if len(y) == 1 and y.top().is_one():
+        if len(y) == 1 and y.top().is_one:
             return x
         elif len(y) == 0:
             return CircuitTable(circuit, x.rv_idxs)
@@ -259,7 +259,7 @@ cpdef object product(x: CircuitTable, y: CircuitTable):  # -> CircuitTable:
             co.append(x_instance[i])
         co_tuple = tuple(co)
 
-        if x_node.is_one():
+        if x_node.is_one:
             # Multiplying by one.
             # Iterate over matching y rows.
             got = y_index.get(co_tuple)
@@ -301,7 +301,7 @@ cdef object _product_no_common_rvs(x: CircuitTable, y: CircuitTable):  # -> Circ
     cdef tuple[int, ...] instance
 
     for x_instance, x_node in x.rows.items():
-        if x_node.is_one():
+        if x_node.is_one:
             for y_instance, y_node in y.rows.items():
                 instance = x_instance + y_instance
                 table.rows[instance] = y_node
@@ -314,12 +314,12 @@ cdef object _product_no_common_rvs(x: CircuitTable, y: CircuitTable):  # -> Circ
 
 
 cdef object _optimised_mul(object circuit: Circuit, object x: CircuitNode, object y: CircuitNode):  # -> CircuitNode
-    if x.is_zero():
+    if x.is_zero:
         return x
-    if y.is_zero():
+    if y.is_zero:
         return y
-    if x.is_one():
+    if x.is_one:
         return y
-    if y.is_one():
+    if y.is_one:
         return x
     return circuit.mul(x, y)