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

ck/circuit/__init__.py

@@ -1,3 +1,7 @@
+# There are two implementations of the `circuit` module are provided
+# for developer R&D purposes. One is pure Python and the other is Cython.
+# Which implementation is used can be selected here.
+
 # from ._circuit_py import (
 from ._circuit_cy import (
     Circuit,

ck/circuit/_circuit_cy.pxd

@@ -0,0 +1,32 @@
+cdef class Circuit:
+    cdef public list[VarNode] vars
+    cdef public list[OpNode] ops
+    cdef public ConstNode zero
+    cdef public ConstNode one
+    cdef dict[object, ConstNode] _const_map
+    cdef object __derivatives
+
+    cdef OpNode op(self, int symbol, tuple[CircuitNode, ...] nodes)
+    cdef list[OpNode] find_reachable_op_nodes(self, list[CircuitNode] nodes)
+    cdef void _remove_unreachable_op_nodes(self, list[CircuitNode] nodes)
+    cdef list[CircuitNode] _check_nodes(self, object nodes)
+    cdef void __check_nodes(self, object nodes, list[CircuitNode] result)
+    cdef object _derivatives(self, CircuitNode f)
+
+cdef class CircuitNode:
+    cdef public Circuit circuit
+    cdef public bint is_zero
+    cdef public bint is_one
+
+cdef class ConstNode(CircuitNode):
+    cdef public object value
+
+cdef class VarNode(CircuitNode):
+    cdef public int idx
+    cdef object _const
+
+    cpdef int is_const(self) except*
+
+cdef class OpNode(CircuitNode):
+    cdef public tuple[object, ...] args
+    cdef public int symbol

ck/circuit/_circuit_cy.pyx

@@ -4,7 +4,7 @@ For more documentation on this module, refer to the Jupyter notebook docs/6_circ
 from __future__ import annotations
 
 from itertools import chain
-from typing import Dict, Tuple, Optional, Iterable, Sequence, List, overload, Any
+from typing import Dict, Optional, Iterable, Sequence, List, overload
 
 # Type for values of ConstNode objects
 ConstValue = float | int | bool
@@ -15,6 +15,8 @@ Args = CircuitNode | ConstValue | Iterable[CircuitNode | ConstValue]
 ADD: int = 0
 MUL: int = 1
 
+cdef int c_ADD = ADD
+cdef int c_MUL = MUL
 
 cdef class Circuit:
     """
@@ -29,13 +31,6 @@ cdef class Circuit:
     `VarNode` may be temporarily be set to a constant value.
     """
 
-    cdef public list[VarNode] vars
-    cdef public list[OpNode] ops
-    cdef public object zero
-    cdef public object one
-    cdef dict[Any, ConstNode] _const_map
-    cdef object __derivatives
-
     def __init__(self, zero: ConstValue = 0, one: ConstValue = 1):
         """
         Construct a new, empty circuit.
@@ -46,13 +41,11 @@ cdef class Circuit:
         """
         self.vars: List[VarNode] = []
         self.ops: List[OpNode] = []
-        self._const_map: Dict[ConstValue, ConstNode] = {}
-        self.__derivatives: Optional[_DerivativeHelper] = None  # cache for partial derivatives calculations.
         self.zero: ConstNode = ConstNode(self, zero, is_zero=True)
         self.one: ConstNode = ConstNode(self, one, is_one=True)
 
-        self._const_map[zero] = self.zero
-        self._const_map[one] = self.one
+        self._const_map: Dict[ConstValue, ConstNode] = {zero: self.zero, one: self.one}
+        self.__derivatives: Optional[_DerivativeHelper] = None  # cache for partial derivatives calculations.
 
     @property
     def number_of_vars(self) -> int:
@@ -127,72 +120,57 @@ cdef class Circuit:
             self._const_map[value] = node
         return node
 
-    cdef OpNode _op(self, int symbol, tuple[CircuitNode, ...] nodes):
-        cdef OpNode node = OpNode(self, symbol, nodes)
-        self.ops.append(node)
-        return node
-
     def add(self, *nodes: Args) -> OpNode:
         """
         Create and return a new 'addition' node, applied to the given arguments.
         """
         cdef list[CircuitNode] args = self._check_nodes(nodes)
-        return self._op(ADD, tuple(args))
+        return self.op(c_ADD, tuple(args))
 
     def mul(self, *nodes: Args) -> OpNode:
         """
         Create and return a new 'multiplication' node, applied to the given arguments.
         """
         cdef list[CircuitNode] args = self._check_nodes(nodes)
-        return self._op(MUL, tuple(args))
+        return self.op(c_MUL, tuple(args))
 
-    cpdef object optimised_add(self, object nodes: Iterable[CircuitNode]):  # -> CircuitNode:
-        # Optimised circuit node addition.
-        #
-        # Performs the following optimisations:
-        # * addition to zero is avoided: add(x, 0) = x,
-        # * singleton addition is avoided: add(x) = x,
-        # * empty addition is avoided: add() = 0.
-
-        cdef list[CircuitNode] to_add = []
-        cdef CircuitNode n
-        for n in nodes:
-            if n.circuit is not self:
-                raise RuntimeError('node does not belong to this circuit')
-            if not n.is_zero:
-                to_add.append(n)
-        cdef int len_to_add = len(to_add)
-        if len_to_add == 0:
+    def optimised_add(self, *args: Args) -> CircuitNode:
+        """
+        Optimised circuit node addition.
+
+        Performs the following optimisations:
+        * addition to zero is avoided: add(x, 0) = x,
+        * singleton addition is avoided: add(x) = x,
+        * empty addition is avoided: add() = 0,
+        """
+        cdef tuple[CircuitNode, ...] to_add = tuple(n for n in self._check_nodes(args) if not n.is_zero)
+        cdef size_t num_to_add = len(to_add)
+        if num_to_add == 0:
             return self.zero
-        elif len_to_add == 1:
+        if num_to_add == 1:
             return to_add[0]
-        else:
-            return self._op(ADD, tuple(to_add))
+        return self.op(c_ADD, to_add)
 
-    cpdef object optimised_mul(self, object nodes: Iterable[CircuitNode]):  # -> CircuitNode:
-        # Optimised circuit node multiplication.
-        #
-        # Performs the following optimisations:
-        # * multiplication by zero is avoided: mul(x, 0) = 0,
-        # * multiplication by one is avoided: mul(x, 1) = x,
-        # * singleton multiplication is avoided: mul(x) = x,
-        # * empty multiplication is avoided: mul() = 1.
-        cdef list[CircuitNode] to_mul = []
-        cdef CircuitNode n
-        for n in nodes:
-            if n.circuit is not self:
-                raise RuntimeError('node does not belong to this circuit')
-            if n.is_zero:
-                return self.zero
-            if not n.is_one:
-                to_mul.append(n)
-        cdef int len_to_mul = len(to_mul)
-        if len_to_mul == 0:
+    def optimised_mul(self, *args: Args) -> CircuitNode:
+        """
+        Optimised circuit node multiplication.
+
+        Performs the following optimisations:
+        * multiplication by zero is avoided: mul(x, 0) = 0,
+        * multiplication by one is avoided: mul(x, 1) = x,
+        * singleton multiplication is avoided: mul(x) = x,
+        * empty multiplication is avoided: mul() = 1,
+        """
+        cdef tuple[CircuitNode, ...] to_mul = tuple(n for n in self._check_nodes(args) if not n.is_one)
+        if any(n.is_zero for n in to_mul):
+            return self.zero
+        cdef Py_ssize_t num_to_mul = len(to_mul)
+
+        if num_to_mul == 0:
             return self.one
-        elif len_to_mul == 1:
+        if num_to_mul == 1:
             return to_mul[0]
-        else:
-            return self._op(MUL, tuple(to_mul))
+        return self.op(c_MUL, to_mul)
 
     def cartesian_product(self, xs: Sequence[CircuitNode], ys: Sequence[CircuitNode]) -> List[CircuitNode]:
         """
@@ -206,12 +184,12 @@ cdef class Circuit:
             a list of 'mul' nodes, one for each combination of xs and ys. The results are in the order
             given by `[mul(x, y) for x in xs for y in ys]`.
         """
-        xs: List[CircuitNode] = self._check_nodes(xs)
-        ys: List[CircuitNode] = self._check_nodes(ys)
+        cdef list[CircuitNode] xs_list = self._check_nodes(xs)
+        cdef list[CircuitNode] ys_list = self._check_nodes(ys)
         return [
-            self.optimised_mul((x, y))
-            for x in xs
-            for y in ys
+            self.optimised_mul(x, y)
+            for x in xs_list
+            for y in ys_list
         ]
 
     @overload
@@ -262,10 +240,10 @@ cdef class Circuit:
             If  `args` is a single CircuitNode, then a single CircuitNode will be returned, otherwise
             a list of CircuitNode is returned.
         """
-        single_result: bool = isinstance(args, CircuitNode)
+        cdef bint single_result = isinstance(args, CircuitNode)
 
-        args: List[CircuitNode] = self._check_nodes([args])
-        if len(args) == 0:
+        cdef list[CircuitNode] args_list = self._check_nodes([args])
+        if len(args_list) == 0:
             # Trivial case
             return []
 
@@ -274,12 +252,12 @@ cdef class Circuit:
         if self_multiply:
             result = [
                 derivatives.derivative_self_mul(arg)
-                for arg in args
+                for arg in args_list
             ]
         else:
             result = [
                 derivatives.derivative(arg)
-                for arg in args
+                for arg in args_list
             ]
 
         if single_result:
@@ -303,26 +281,8 @@ cdef class Circuit:
         Args:
             *nodes: may be either a node or a list of nodes.
         """
-        nodes = self._check_nodes(nodes)
-        self._remove_unreachable_op_nodes(nodes)
-
-    cdef void _remove_unreachable_op_nodes(self, list[CircuitNode] nodes):
-        # Set of object ids for all reachable op nodes
-        cdef set[int] seen = set()
-
-        cdef CircuitNode node
-        for node in nodes:
-            _reachable_op_nodes_seen_r(node, seen)
-
-        if len(seen) < len(self.ops):
-            # Invalidate unreadable op nodes
-            for op_node in self.ops:
-                if id(op_node) not in seen:
-                    op_node.circuit = None
-                    op_node.args = ()
-
-            # Keep only reachable op nodes, in the same order as `self.ops`.
-            self.ops = [op_node for op_node in self.ops if id(op_node) in seen]
+        cdef list[CircuitNode] node_list = self._check_nodes(nodes)
+        self._remove_unreachable_op_nodes(node_list)
 
     def reachable_op_nodes(self, *nodes: Args) -> List[OpNode]:
         """
@@ -338,19 +298,8 @@ cdef class Circuit:
             Returned nodes are not repeated.
             The result is ordered such that if result[i] is referenced by result[j] then i < j.
         """
-        nodes = self._check_nodes(nodes)
-        return self._reachable_op_nodes(nodes)
-
-    cdef list[OpNode] _reachable_op_nodes(self, list[CircuitNode] nodes):
-        # Set of object ids for all reachable op nodes
-        cdef set[int] seen = set()
-
-        cdef list[OpNode] result = []
-
-        cdef CircuitNode node
-        for node in nodes:
-            _reachable_op_nodes_r(node, seen, result)
-        return result
+        cdef list[CircuitNode] node_list = self._check_nodes(nodes)
+        return self.find_reachable_op_nodes(node_list)
 
     def dump(
             self,
@@ -415,8 +364,42 @@ cdef class Circuit:
             args_str = ' '.join(node_name[id(arg)] for arg in op.args)
             print(f'{next_prefix}{op_name}: {args_str}')
 
+    cdef OpNode op(self, int symbol, tuple[CircuitNode, ...] nodes):
+        cdef OpNode node = OpNode(self, symbol, nodes)
+        self.ops.append(node)
+        return node
+
+    cdef list[OpNode] find_reachable_op_nodes(self, list[CircuitNode] nodes):
+        # Set of object ids for all reachable op nodes
+        cdef set[int] seen = set()
+
+        cdef list[OpNode] result = []
+
+        cdef CircuitNode node
+        for node in nodes:
+            find_reachable_op_nodes_r(node, seen, result)
+        return result
+
+    cdef void _remove_unreachable_op_nodes(self, list[CircuitNode] nodes):
+        # Set of object ids for all reachable op nodes
+        cdef set[int] seen = set()
+
+        cdef CircuitNode node
+        for node in nodes:
+            find_reachable_op_nodes_seen_r(node, seen)
+
+        if len(seen) < len(self.ops):
+            # Invalidate unreadable op nodes
+            for op_node in self.ops:
+                if id(op_node) not in seen:
+                    op_node.circuit = None
+                    op_node.args = ()
+
+            # Keep only reachable op nodes, in the same order as `self.ops`.
+            self.ops = [op_node for op_node in self.ops if id(op_node) in seen]
+
     cdef list[CircuitNode] _check_nodes(self, object nodes: Iterable[Args]):  # -> Sequence[CircuitNode]:
-        # Convert the given circuit nodes to a tuple, flattening nested iterables as needed.
+        # Convert the given circuit nodes to a list, flattening nested iterables as needed.
         #
         # Args:
         #     nodes: some circuit nodes of constant values.
@@ -427,8 +410,8 @@ cdef class Circuit:
         self.__check_nodes(nodes, result)
         return result
 
-    cdef void __check_nodes(self, nodes: Iterable[Args], list[CircuitNode] result):
-        # Convert the given circuit nodes to a tuple, flattening nested iterables as needed.
+    cdef void __check_nodes(self, object nodes: Iterable[Args], list[CircuitNode] result):
+        # Convert the given circuit nodes to a list, flattening nested iterables as needed.
         #
         # Args:
         #     nodes: some circuit nodes of constant values.
@@ -455,7 +438,6 @@ cdef class Circuit:
             self.__derivatives = derivatives
         return derivatives
 
-
 cdef class CircuitNode:
     """
     A node in an arithmetic circuit.
@@ -470,9 +452,6 @@ cdef class CircuitNode:
     A var node may be temporarily set to be a constant node, which may
     be useful for optimising a compiled circuit.
     """
-    cdef public Circuit circuit
-    cdef public bint is_zero
-    cdef public bint is_one
 
     def __init__(self, circuit: Circuit, is_zero: bool, is_one: bool):
         self.circuit = circuit
@@ -485,11 +464,10 @@ cdef class CircuitNode:
     def __mul__(self, other: CircuitNode | ConstValue):
         return self.circuit.mul(self, other)
 
-
 cdef class ConstNode(CircuitNode):
-    # A node in a circuit representing a constant value.
-
-    cdef public object value
+    """
+    A node in a circuit representing a constant value.
+    """
 
     def __init__(self, circuit, value: ConstValue, is_zero: bool = False, is_one: bool = False):
         super().__init__(circuit, is_zero, is_one)
@@ -504,13 +482,10 @@ cdef class ConstNode(CircuitNode):
         else:
             return False
 
-
 cdef class VarNode(CircuitNode):
     """
     A node in a circuit representing an input variable.
     """
-    cdef public int idx
-    cdef object _const
 
     def __init__(self, circuit, idx: int):
         super().__init__(circuit, False, False)
@@ -552,13 +527,11 @@ cdef class OpNode(CircuitNode):
     """
     A node in a circuit representing an arithmetic operation.
     """
-    cdef public tuple[object, ...] args
-    cdef public int symbol
 
-    def __init__(self, object circuit, symbol: int, tuple[object, ...] args: Tuple[CircuitNode]):
+    def __init__(self, Circuit circuit, int symbol, tuple[CircuitNode, ...] args):
         super().__init__(circuit, False, False)
         self.args = tuple(args)
-        self.symbol = int(symbol)
+        self.symbol = <int> symbol
 
     def __str__(self) -> str:
         return f'{self.op_str()}\\{len(self.args)}'
@@ -567,9 +540,9 @@ cdef class OpNode(CircuitNode):
         """
         Returns the op node operation as a string.
         """
-        if self.symbol == MUL:
+        if self.symbol == c_MUL:
             return 'mul'
-        elif self.symbol == ADD:
+        elif self.symbol == c_ADD:
             return 'add'
         else:
             return '?' + str(self.symbol)
@@ -579,11 +552,11 @@ cdef class _DNode:
     A data structure supporting derivative calculations.
     A DNode holds all information needed to calculate the partial derivative at `node`.
     """
-    cdef public object node
-    cdef public object derivative
-    cdef public object derivative_self_mul
-    cdef public list sum_prod
-    cdef public bint processed
+    cdef CircuitNode node
+    cdef object derivative
+    cdef object derivative_self_mul
+    cdef list[_DNodeProduct] sum_prod
+    cdef bint processed
 
     def __init__(
             self,
@@ -615,8 +588,8 @@ cdef class _DNodeProduct:
 
     The represents a product of `parent` and `prod`.
     """
-    cdef public object parent
-    cdef public list prod
+    cdef _DNode parent
+    cdef list[CircuitNode] prod
 
     def __init__(self, parent: _DNode, prod: List[CircuitNode]):
         self.parent = parent
@@ -629,33 +602,40 @@ cdef class _DNodeProduct:
         return 'DNodeProduct(' + str(self.parent) + ', ' + str(self.prod) + ')'
 
 
-class _DerivativeHelper:
+cdef class _DerivativeHelper:
     """
     A data structure to support efficient calculation of partial derivatives
     with respect to some function node `f`.
     """
 
+    cdef CircuitNode f
+    cdef CircuitNode zero
+    cdef CircuitNode one
+    cdef Circuit circuit
+    cdef dict[int, _DNode] d_nodes
+
     def __init__(self, f: CircuitNode):
         """
         Prepare to calculate partial derivatives with respect to `f`.
         """
-        self.f: CircuitNode = f
-        self.circuit: Circuit = f.circuit
-        self.d_nodes: Dict[int, _DNode] = {}  # map id(CircuitNode) to its DNode
+        self.f = f
+        self.circuit = f.circuit
+        self.d_nodes = {}  # map id(CircuitNode) to its DNode
         self.zero = self.circuit.zero
         self.one = self.circuit.one
-        top_d_node: _DNode = _DNode(f, self.one)
+
+        cdef _DNode top_d_node = _DNode(f, self.one)
         self.d_nodes[id(f)] = top_d_node
         self._mk_derivative_r(top_d_node)
 
-    def derivative(self, node: CircuitNode) -> CircuitNode:
+    cdef CircuitNode derivative(self, CircuitNode node):
         d_node: Optional[_DNode] = self.d_nodes.get(id(node))
         if d_node is None:
             return self.zero
         else:
             return self._derivative(d_node)
 
-    def derivative_self_mul(self, node: CircuitNode) -> CircuitNode:
+    cdef CircuitNode derivative_self_mul(self, CircuitNode node):
         d_node: Optional[_DNode] = self.d_nodes.get(id(node))
         if d_node is None:
             return self.zero
@@ -667,11 +647,11 @@ class _DerivativeHelper:
             elif d is self.one:
                 d_node.derivative_self_mul = node
             else:
-                d_node.derivative_self_mul = self.circuit.optimised_mul((d, node))
+                d_node.derivative_self_mul = self.circuit.optimised_mul(d, node)
 
         return d_node.derivative_self_mul
 
-    def _derivative(self, d_node: _DNode) -> CircuitNode:
+    cdef CircuitNode _derivative(self, _DNode d_node):
         if d_node.derivative is not None:
             return d_node.derivative
 
@@ -685,14 +665,13 @@ class _DerivativeHelper:
         d_node.sum_prod = None
 
         # Construct the addition operation
-        d_node.derivative = self.circuit.optimised_add(to_add)
+        d_node.derivative = self.circuit.optimised_add(*to_add)
 
         return d_node.derivative
 
-    def _derivative_prod(self, prods: _DNodeProduct) -> CircuitNode:
-        """
-        Support `_derivative` by constructing the derivative product for the given _DNodeProduct.
-        """
+    cdef CircuitNode _derivative_prod(self, _DNodeProduct prods):
+        # Support `_derivative` by constructing the derivative product for the given _DNodeProduct.
+
         # Get the derivative of the parent node.
         parent: CircuitNode = self._derivative(prods.parent)
 
@@ -706,59 +685,56 @@ class _DerivativeHelper:
                 to_mul.append(arg)
 
         # Construct the multiplication operation
-        return self.circuit.optimised_mul(to_mul)
+        return self.circuit.optimised_mul(*to_mul)
+
+    cdef void _mk_derivative_r(self, _DNode d_node):
+        # Construct a DNode for each argument of the given DNode.
 
-    def _mk_derivative_r(self, d_node: _DNode) -> None:
-        """
-        Construct a DNode for each argument of the given DNode.
-        """
         if d_node.processed:
             return
         d_node.processed = True
         node: CircuitNode = d_node.node
 
         if isinstance(node, OpNode):
-            if node.symbol == ADD:
+            if node.symbol == c_ADD:
                 for arg in node.args:
                     child_d_node = self._add(arg, d_node, [])
                     self._mk_derivative_r(child_d_node)
-            elif node.symbol == MUL:
+            elif node.symbol == c_MUL:
                 for arg in node.args:
                     prod = [arg2 for arg2 in node.args if arg is not arg2]
                     child_d_node = self._add(arg, d_node, prod)
                     self._mk_derivative_r(child_d_node)
 
-    def _add(self, node: CircuitNode, parent: _DNode, prod: List[CircuitNode]) -> _DNode:
-        """
-        Support for `_mk_derivative_r`.
-
-        Add a _DNodeProduct(parent, negate, prod) to the DNode for the given circuit node.
-
-        If the DNode for `node` does not yet exist, one will be created.
-
-        The given circuit node may have multiple parents (i.e., a shared sub-expression). Therefore,
-        this method may be called multiple times for a given node. Each time a new _DNodeProduct will be added.
-
-        Args:
-            node: the CircuitNode that the returned DNode is for.
-            parent: the DNode of the parent node, i.e., `node` is an argument to the parent node.
-            prod: other circuit nodes that need to be multiplied with the parent derivative when
-                constructing a derivative for `node`.
+    cdef _DNode _add(self, CircuitNode node, _DNode parent,  list[CircuitNode] prod):
+        # Support for `_mk_derivative_r`.
+        #
+        # Add a _DNodeProduct(parent, negate, prod) to the DNode for the given circuit node.
+        #
+        # If the DNode for `node` does not yet exist, one will be created.
+        #
+        # The given circuit node may have multiple parents (i.e., a shared sub-expression). Therefore,
+        # this method may be called multiple times for a given node. Each time a new _DNodeProduct will be added.
+        #
+        # Args:
+        #     node: the CircuitNode that the returned DNode is for.
+        #     parent: the DNode of the parent node, i.e., `node` is an argument to the parent node.
+        #     prod: other circuit nodes that need to be multiplied with the parent derivative when
+        #         constructing a derivative for `node`.
+        #
+        # Returns:
+        #     the DNode for `node`.
 
-        Returns:
-            the DNode for `node`.
-        """
         child_d_node: _DNode = self._get(node)
         child_d_node.sum_prod.append(_DNodeProduct(parent, prod))
         return child_d_node
 
-    def _get(self, node: CircuitNode) -> _DNode:
-        """
-        Helper for derivatives.
+    cdef _DNode _get(self, CircuitNode node):
+        # Helper for derivatives.
+        #
+        # Get the DNode for the given circuit node.
+        # If no DNode exist for it yet, then one will be constructed.
 
-        Get the DNode for the given circuit node.
-        If no DNode exist for it yet, then one will be constructed.
-        """
         node_id: int = id(node)
         d_node: Optional[_DNode] = self.d_nodes.get(node_id)
         if d_node is None:
@@ -767,7 +743,7 @@ class _DerivativeHelper:
         return d_node
 
 
-cdef void _reachable_op_nodes_r(CircuitNode node, set[int] seen, list[OpNode] result):
+cdef void find_reachable_op_nodes_r(CircuitNode node, set[int] seen, list[OpNode] result):
     # Recursive helper for `reachable_op_nodes`. Performs a depth-first search.
     #
     # Args:
@@ -777,11 +753,10 @@ cdef void _reachable_op_nodes_r(CircuitNode node, set[int] seen, list[OpNode] re
     if isinstance(node, OpNode) and id(node) not in seen:
         seen.add(id(node))
         for arg in node.args:
-            _reachable_op_nodes_r(arg, seen, result)
+            find_reachable_op_nodes_r(arg, seen, result)
         result.append(node)
 
-
-cdef void _reachable_op_nodes_seen_r(CircuitNode node, set[int] seen):
+cdef void find_reachable_op_nodes_seen_r(CircuitNode node, set[int] seen):
     # Recursive helper for `remove_unreachable_op_nodes`. Performs a depth-first search.
     #
     # Args:
@@ -790,4 +765,4 @@ cdef void _reachable_op_nodes_seen_r(CircuitNode node, set[int] seen):
     if isinstance(node, OpNode) and id(node) not in seen:
         seen.add(id(node))
         for arg in node.args:
-            _reachable_op_nodes_seen_r(arg, seen)
+            find_reachable_op_nodes_seen_r(arg, seen)

ck/circuit/_circuit_py.py

@@ -721,7 +721,7 @@ class _DerivativeHelper:
         d_node.sum_prod = None
 
         # Construct the addition operation
-        d_node.derivative = self.circuit.optimised_add(to_add)
+        d_node.derivative = self.circuit.optimised_add(*to_add)
 
         return d_node.derivative
 
@@ -742,7 +742,7 @@ class _DerivativeHelper:
                 to_mul.append(arg)
 
         # Construct the multiplication operation
-        return self.circuit.optimised_mul(to_mul)
+        return self.circuit.optimised_mul(*to_mul)
 
     def _mk_derivative_r(self, d_node: _DNode) -> None:
         """