compiled-knowledge 4.0.0a12__cp312-cp312-win_amd64.whl → 4.0.0a16__cp312-cp312-win_amd64.whl

ck/circuit_compiler/named_circuit_compilers.py

@@ -18,19 +18,19 @@ class NamedCircuitCompiler(Enum):
     Each member itself is callable, conforming to the CircuitCompiler protocol, delegating to the compiler function.
     """
 
-    LLVM_STACK: CircuitCompiler = (partial(llvm_compiler.compile_circuit, flavour=Flavour.STACK),)
-    LLVM_TMPS: CircuitCompiler = (partial(llvm_compiler.compile_circuit, flavour=Flavour.TMPS, opt=0),)
-    LLVM_VM: CircuitCompiler = (llvm_vm_compiler.compile_circuit,)
-    CYTHON_VM: CircuitCompiler = (cython_vm_compiler.compile_circuit,)
-    INTERPRET: CircuitCompiler = (interpret_compiler.compile_circuit,)
+    LLVM_STACK = (partial(llvm_compiler.compile_circuit, flavour=Flavour.STACK),)
+    LLVM_TMPS = (partial(llvm_compiler.compile_circuit, flavour=Flavour.TMPS, opt=0),)
+    LLVM_VM = (llvm_vm_compiler.compile_circuit,)
+    CYTHON_VM = (cython_vm_compiler.compile_circuit,)
+    INTERPRET = (interpret_compiler.compile_circuit,)
 
-    # The following circuit compilers were experimental but are not really useful
+    # The following circuit compilers were experimental but are not really useful.
     #
     # Slow compile and execution:
-    # LLVM_FUNCS: CircuitCompiler = (partial(llvm_compiler.compile_circuit, flavour=Flavour.FUNCS, opt=0),)
+    # LLVM_FUNCS = (partial(llvm_compiler.compile_circuit, flavour=Flavour.FUNCS, opt=0),)
     #
     # Slow compile and same execution as LLVM_VM:
-    # LLVM_VM_COMPILED_ARRAYS: CircuitCompiler = (partial(llvm_vm_compiler.compile_circuit, compile_arrays=True),)
+    # LLVM_VM_COMPILED_ARRAYS = (partial(llvm_vm_compiler.compile_circuit, compile_arrays=True),)
 
     def __call__(
             self,

ck/example/pathfinder.py

@@ -2,25 +2,33 @@ from ck.pgm import PGM
 
 
 class Pathfinder(PGM):
+    """
+    This implementation of the Pathfinder PGM has 93 states for the "Fault" random
+    variable, and its factor has been normalised to be a CPT.
+    """
 
     def __init__(self):
         super().__init__(self.__class__.__name__)
 
         pgm_rv0 = self.new_rv('Fault', (
-        'AIDS early', 'AILD', 'ALIP', 'Cat scratch disease', 'Dermatopathic laden', 'Florid follic hyperp',
-        'GLH hyaline vascular', 'GLH plasma cell', 'Granulomatous laden', 'Histiocytosis x', 'Infectious mono',
-        'Leprosy-lepromatous', 'Lymphangiographic', 'Mantle zone hyperpla', 'Necrotizing Kikuchi',
-        'Necrotiz non-Kikuchi', 'Rheumatoid arthritis', 'Sarcoidosis', 'SHML', 'Sinus histiocytosis', 'Syphilis',
-        'Toxoplasmosis', 'Tuberculosis', 'Viral NOS', "Whipple's disease", 'L&H nodular HD', 'L&H diffuse HD',
-        'Nodular sclerosis HD', 'Cellular phase NSHD', 'Syncytial NSHD', 'Mixed cellularity HD', 'Interfollicular HD',
-        'Diffuse fibrosis HD', 'Reticular-type HD', 'Small cleaved fol', 'Mixed fol', 'Large cell fol',
-        'Small noncleaved fol', 'Small lymphocytic', 'Plasmacytoid lyctic', 'Mantle zone lymphoma', 'Small cleaved dif',
-        'Mixed FCC dif', 'Large cell dif', 'B-immunoblastic', 'T-immunob mixed', 'AILD-like T-cell lym', 'Japanese ATL',
-        'Lymphoblastic', 'Small noncleaved dif', 'True histiocytic', 'Ki-1 LC anaplas T', 'Multiple myeloma',
-        'Mycosis fungoides', 'AML', 'Hairy cell leukemia', 'Carcinoma', 'Melanoma', 'EM plasmacytoma',
-        "Kaposi's sarcoma", 'Mast-cell disease', 'AIDS involutionary', 'T-immunob large', 'Monocytoid B-cell',
-        'Nasopharyngeal CA', 'Seminoma', 'SLE', 'Mycobact histiocytos', 'Mast-cell hyperplas', 'LGV', 'Histoplasmosis',
-        'Coccidioidomycosis', 'CMV', 'Brucellosis', 'Ki-1 LC anaplas B', 'Intermed lymphocytic'))
+            'AIDS early', 'AILD', 'ALIP', 'Cat scratch disease', 'Dermatopathic laden', 'Florid follic hyperp',
+            'GLH hyaline vascular', 'GLH plasma cell', 'Granulomatous laden', 'Histiocytosis x', 'Infectious mono',
+            'Leprosy-lepromatous', 'Lymphangiographic', 'Mantle zone hyperpla', 'Necrotizing Kikuchi',
+            'Necrotiz non-Kikuchi', 'Rheumatoid arthritis', 'Sarcoidosis', 'SHML', 'Sinus histiocytosis', 'Syphilis',
+            'Toxoplasmosis', 'Tuberculosis', 'Viral NOS', "Whipple's disease", 'L&H nodular HD', 'L&H diffuse HD',
+            'Nodular sclerosis HD', 'Cellular phase NSHD', 'Syncytial NSHD', 'Mixed cellularity HD',
+            'Interfollicular HD',
+            'Diffuse fibrosis HD', 'Reticular-type HD', 'Small cleaved fol', 'Mixed fol', 'Large cell fol',
+            'Small noncleaved fol', 'Small lymphocytic', 'Plasmacytoid lyctic', 'Mantle zone lymphoma',
+            'Small cleaved dif',
+            'Mixed FCC dif', 'Large cell dif', 'B-immunoblastic', 'T-immunob mixed', 'AILD-like T-cell lym',
+            'Japanese ATL',
+            'Lymphoblastic', 'Small noncleaved dif', 'True histiocytic', 'Ki-1 LC anaplas T', 'Multiple myeloma',
+            'Mycosis fungoides', 'AML', 'Hairy cell leukemia', 'Carcinoma', 'Melanoma', 'EM plasmacytoma',
+            "Kaposi's sarcoma", 'Mast-cell disease', 'AIDS involutionary', 'T-immunob large', 'Monocytoid B-cell',
+            'Nasopharyngeal CA', 'Seminoma', 'SLE', 'Mycobact histiocytos', 'Mast-cell hyperplas', 'LGV',
+            'Histoplasmosis',
+            'Coccidioidomycosis', 'CMV', 'Brucellosis', 'Ki-1 LC anaplas B', 'Intermed lymphocytic'))
         pgm_rv1 = self.new_rv('ACID', ('Negative', 'Positive'))
         pgm_rv2 = self.new_rv('F_CSA', ('No follicles', 'Absent', 'Present'))
         pgm_rv3 = self.new_rv('F_ISL', ('No follicles', 'Absent', 'Present'))
@@ -58,25 +66,27 @@ class Pathfinder(PGM):
                                ('Absent [0]', 'Rare [1-5]', 'Few [6-25]', 'Many [26-100]', 'Striking [>100]'))
         pgm_rv34 = self.new_rv('LH_NOD', ('Absent', 'Present'))
         pgm_rv35 = self.new_rv('LACUN', (
-        'Absent [0]', 'Rare [1-5]', 'Few [6-25]', 'Many [26 - 100]', 'Striking [>100]', 'Sheets [>50pc of section]'))
+            'Absent [0]', 'Rare [1-5]', 'Few [6-25]', 'Many [26 - 100]', 'Striking [>100]',
+            'Sheets [>50pc of section]'))
         pgm_rv36 = self.new_rv('LANG', ('Absent [0]', 'Present [1-5]', 'Prominent [>5]'))
         pgm_rv37 = self.new_rv('LEUK', ('Absent', 'Present'))
         pgm_rv38 = self.new_rv('LLC_CY', ('No LLCs', 'Scanty', 'Moderate-abundant clear', 'Moderate-abundant deep'))
         pgm_rv39 = self.new_rv('LLC_NS', (
-        'No LLCs', 'Multilobated [some]', 'Cerebriform/Mulberry [some]', 'Convoluted [some]', 'Irregular [most]',
-        'Round/slightly irregular [most]'))
+            'No LLCs', 'Multilobated [some]', 'Cerebriform/Mulberry [some]', 'Convoluted [some]', 'Irregular [most]',
+            'Round/slightly irregular [most]'))
         pgm_rv40 = self.new_rv('LLC', (
-        'Absent [0pc]', 'Sparse [<10pc]', 'Moderate [11-50pc]', 'Numerous [51-90pc]', 'Striking [>90pc]'))
+            'Absent [0pc]', 'Sparse [<10pc]', 'Moderate [11-50pc]', 'Numerous [51-90pc]', 'Striking [>90pc]'))
         pgm_rv41 = self.new_rv('F_POPU', (
-        'No follicles', '>80pc 6-12u', '>50pc 13-20u with nucleoli', '>50pc >20u with nucleoli', 'Other'))
+            'No follicles', '>80pc 6-12u', '>50pc 13-20u with nucleoli', '>50pc >20u with nucleoli', 'Other'))
         pgm_rv42 = self.new_rv('MAST', ('Absent [0]', 'Present [1-50]', 'Prominent [>50]'))
         pgm_rv43 = self.new_rv('MLC', (
-        'Absent [0pc]', 'Sparse [<10pc]', 'Moderate [11-50pc]', 'Numerous [51-90pc]', 'Striking [>90pc]'))
+            'Absent [0pc]', 'Sparse [<10pc]', 'Moderate [11-50pc]', 'Numerous [51-90pc]', 'Striking [>90pc]'))
         pgm_rv44 = self.new_rv('MELANOMA', ('Absent', 'Present'))
         pgm_rv45 = self.new_rv('MF10HP', ('0-5', '6-15', '16-50', '>50'))
         pgm_rv46 = self.new_rv('MLC_CY', ('No MLCs', 'Scanty', 'Moderate-abundant clear', 'Moderate-abundant deep'))
         pgm_rv47 = self.new_rv('MLC_NS', (
-        'No MLCs', 'Cerebriform [some]', 'Convoluted [some]', 'Irregular [most]', 'Round/slightly irregular [most]'))
+            'No MLCs', 'Cerebriform [some]', 'Convoluted [some]', 'Irregular [most]',
+            'Round/slightly irregular [most]'))
         pgm_rv48 = self.new_rv('MLC_NI', ('No MLCs', 'Absent to rare', 'Large central', 'Peripheral', 'Other'))
         pgm_rv49 = self.new_rv('MCC', ('Absent [0pc]', 'Present [<5pc]', 'Prominent [5-50pc]', 'Confluence [>50pc]'))
         pgm_rv50 = self.new_rv('MONO', ('Absent [0]', 'Rare [1-2]', 'Present [3-20]', 'Many [>20]'))
@@ -90,7 +100,8 @@ class Pathfinder(PGM):
         pgm_rv57 = self.new_rv('PAS', ('No', 'Yes'))
         pgm_rv58 = self.new_rv('PI', ('Absent', 'Present', 'Prominent'))
         pgm_rv59 = self.new_rv('PLASMA', (
-        'Absent [0pc]', 'Few [<5pc]', 'Moderate [6-20pc]', 'Marked [21-50pc]', 'Striking [51-90pc]', 'Sheets [>90pc]'))
+            'Absent [0pc]', 'Few [<5pc]', 'Moderate [6-20pc]', 'Marked [21-50pc]', 'Striking [51-90pc]',
+            'Sheets [>90pc]'))
         pgm_rv60 = self.new_rv('PC_TP', ('No plasma cells', 'Mature', 'Immature', 'Blastic', 'Pleomorphic', 'Mixed'))
         pgm_rv61 = self.new_rv('PLEO', ('Absent [0]', 'Rare [1-5]', 'Few [6-25]', 'Many [26-100]', 'Striking [>100]'))
         pgm_rv62 = self.new_rv('PFP', ('Absent', 'Present'))
@@ -101,10 +112,10 @@ class Pathfinder(PGM):
         pgm_rv67 = self.new_rv('S_RING', ('Absent', 'Present'))
         pgm_rv68 = self.new_rv('SLC_CY', ('No SLCs', 'Scanty', 'Moderate-abundant clear', 'Moderate-abundant deep'))
         pgm_rv69 = self.new_rv('SLC_NS', (
-        'No SLCs', 'Cerebriform [some]', 'Convoluted [some]', 'Moderate-mark irregular [most]',
-        'Round/slightly irregular [most]'))
+            'No SLCs', 'Cerebriform [some]', 'Convoluted [some]', 'Moderate-mark irregular [most]',
+            'Round/slightly irregular [most]'))
         pgm_rv70 = self.new_rv('SLC', (
-        'Absent [0pc]', 'Sparse [1-10pc]', 'Moderate [11-50pc]', 'Numerous [51-90pc]', 'Striking [>90pc]'))
+            'Absent [0pc]', 'Sparse [1-10pc]', 'Moderate [11-50pc]', 'Numerous [51-90pc]', 'Striking [>90pc]'))
         pgm_rv71 = self.new_rv('SINUSES', ('Distended', 'Patent', 'Part-greatly obliterated', 'Completely obliterated'))
         pgm_rv72 = self.new_rv('VASC_C', ('Absent', 'Present'))
         pgm_rv73 = self.new_rv('VASC_NS', ('Absent', 'Slight', 'Moderate', 'Marked', 'Pronounced'))
@@ -123,11 +134,12 @@ class Pathfinder(PGM):
         pgm_rv86 = self.new_rv('F_SS',
                                ('No follicles', 'Absent [0]', 'Slight [1-15]', 'Moderate [16-30]', 'Marked [>30]'))
         pgm_rv87 = self.new_rv('F_MZSTAT', (
-        'No follicles/no mantle zones', 'Mantle zones absent in most follicles', 'Most incompletely surround follicles',
-        'Most completely surround fol not thick', 'Most thick [>10 lymphocytes]'))
+            'No follicles/no mantle zones', 'Mantle zones absent in most follicles',
+            'Most incompletely surround follicles',
+            'Most completely surround fol not thick', 'Most thick [>10 lymphocytes]'))
         pgm_rv88 = self.new_rv('F_MZCM', ('No follicles/no mantle zones', 'Absent', 'Present'))
         pgm_rv89 = self.new_rv('F_DEF', (
-        'No follicles', 'Almost all well defined', 'Both well and poor defined', 'Almost all poor defined'))
+            'No follicles', 'Almost all well defined', 'Both well and poor defined', 'Almost all poor defined'))
         pgm_rv90 = self.new_rv('F_MITO', ('No follicles', '0-20', '21-50', '>50'))
         pgm_rv91 = self.new_rv('F_MZ', ('No follicles', 'Absent', 'Present'))
         pgm_rv92 = self.new_rv('F_CIO', ('No follicles', 'Most similar', 'Some similar', 'None similar'))
@@ -169,13 +181,14 @@ class Pathfinder(PGM):
         pgm_rv128 = self.new_rv('TB', ('Absent', 'Present', 'Prominent'))
         pgm_rv129 = self.new_rv('MELANIN', ('Absent to normal', 'Present', 'Prominent'))
         pgm_rv130 = self.new_rv('MC_SL_NS', (
-        'No follicles/no mantle zones', 'Round', 'Slightly irregular', 'Moderately irregular', 'Markedly irregular'))
+            'No follicles/no mantle zones', 'Round', 'Slightly irregular', 'Moderately irregular',
+            'Markedly irregular'))
         pgm_rv131 = self.new_rv('FMZ_FUS', (
-        'No thick mantle zones', 'No nodules no fusion', 'Nodules but no fusion', 'Fusion with or without nodules'))
+            'No thick mantle zones', 'No nodules no fusion', 'Nodules but no fusion', 'Fusion with or without nodules'))
         pgm_rv132 = self.new_rv('BH_NOS_L', ('No NOS benign histiocytes', 'Mainly interfollicular', 'Mainly sinusoidal',
                                              'Both interfollicular and sinusoidal'))
         pgm_rv133 = self.new_rv('SLC_NI', (
-        'No SLCs', 'None identifiable', '1 or more peripheral small', '1 central medium to large', 'Other'))
+            'No SLCs', 'None identifiable', '1 or more peripheral small', '1 central medium to large', 'Other'))
         pgm_rv134 = self.new_rv('HYALIN', ('Absent', 'Present', 'Prominent'))
         pgm_factor0 = self.new_factor(pgm_rv0)
         pgm_factor1 = self.new_factor(pgm_rv1, pgm_rv128)
@@ -315,22 +328,82 @@ class Pathfinder(PGM):
 
         pgm_function0 = pgm_factor0.set_dense()
         pgm_function0.set_flat(
-            20.0, 1.5, 5.0, 5.0, 25.0,
-            25.0, 5.0, 5.0, 15.0, 4.0,
-            2.0, 2.0, 5.0, 12.5, 8.0,
-            12.8, 2.0, 2.0, 3.0, 20.0,
-            2.0, 5.0, 4.0, 15.0, 0.5,
-            15.0, 2.5, 90.0, 8.0, 8.0,
-            70.0, 5.0, 3.0, 3.0, 110.0,
-            55.0, 20.0, 5.0, 40.0, 8.0,
-            10.0, 5.0, 6.0, 110.0, 20.0,
-            20.0, 12.0, 2.0, 10.0, 80.0,
-            1.0, 15.0, 2.0, 3.0, 5.0,
-            0.1, 20.0, 8.0, 5.0, 8.0,
-            2.0, 20.0, 25.0, 20.0, 5.0,
-            2.0, 2.0, 2.0, 2.0, 2.0,
-            2.0, 2.0, 5.0, 0.25, 4.0,
-            8.0
+            0.018279029,
+            0.001370927,
+            0.004569757,
+            0.004569757,
+            0.022848787,
+            0.022848787,
+            0.004569757,
+            0.004569757,
+            0.013709272,
+            0.003655806,
+            0.001827903,
+            0.001827903,
+            0.004569757,
+            0.011424393,
+            0.007311612,
+            0.011698579,
+            0.001827903,
+            0.001827903,
+            0.002741854,
+            0.018279029,
+            0.001827903,
+            0.004569757,
+            0.003655806,
+            0.013709272,
+            0.000456976,
+            0.013709272,
+            0.002284879,
+            0.082255632,
+            0.007311612,
+            0.007311612,
+            0.063976603,
+            0.004569757,
+            0.002741854,
+            0.002741854,
+            0.100534662,
+            0.050267331,
+            0.018279029,
+            0.004569757,
+            0.036558059,
+            0.007311612,
+            0.009139515,
+            0.004569757,
+            0.005483709,
+            0.100534662,
+            0.018279029,
+            0.018279029,
+            0.010967418,
+            0.001827903,
+            0.009139515,
+            0.073116118,
+            0.000913951,
+            0.013709272,
+            0.001827903,
+            0.002741854,
+            0.004569757,
+            9.13951E-05,
+            0.018279029,
+            0.007311612,
+            0.004569757,
+            0.007311612,
+            0.001827903,
+            0.018279029,
+            0.022848787,
+            0.018279029,
+            0.004569757,
+            0.001827903,
+            0.001827903,
+            0.001827903,
+            0.001827903,
+            0.001827903,
+            0.001827903,
+            0.001827903,
+            0.004569757,
+            0.000228488,
+            0.003655806,
+            0.007311612,
         )
 
         pgm_function1 = pgm_factor1.set_dense()

ck/in_out/parse_ace_lmap.py

@@ -108,7 +108,7 @@ class Parser(ABC):
         except ParseError as e:
             raise e
         except Exception as e:
-            input_stream.raise_error(e)
+            input_stream.raise_error(str(e))
 
     @abstractmethod
     def comment(self, raise_f, message: str) -> None:

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,28 +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,
     )
 
-    # Build the slot map from indicator to slot
-    slot_map: Dict[SlotKey, int] = {
-        indicator: literal_slot_map[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
 
@@ -88,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,
@@ -99,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):
@@ -188,12 +212,14 @@ 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:
             raise e
         except Exception as e:
-            input_stream.raise_error(e)
+            input_stream.raise_error(str(e))
 
     @abstractmethod
     def comment(self, raise_f, message: str) -> None:
@@ -226,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
@@ -247,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
 
@@ -101,16 +102,13 @@ def compile_pgm(
             node_names: List[str] = render_bayesian_network(pgm, file, check_structure_bayesian=False)
 
         # Run Ace
-        ace_result: subprocess.CompletedProcess = subprocess.run(ace_cmd, capture_output=True, text=True)
-        if print_output:
-            print(ace_result.stdout)
-            print(ace_result.stderr)
+        ace_result: subprocess.CompletedProcess = subprocess.run(ace_cmd, capture_output=(not print_output), text=True)
         if ace_result.returncode != 0:
             raise subprocess.CalledProcessError(
                 returncode=ace_result.returncode,
                 cmd=' '.join(ace_cmd),
-                output=ace_result.stdout,
-                stderr=ace_result.stderr,
+                output=None if print_output else ace_result.stdout,
+                stderr=None if print_output else ace_result.stderr,
             )
 
         # Parse the literal map output from Ace
@@ -124,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
@@ -201,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

@@ -21,7 +21,7 @@ def compile_pgm(
         *,
         algorithm: JoinTreeAlgorithm = MIN_FILL_THEN_DEGREE,
         limit_product_tree_search: int = DEFAULT_PRODUCT_SEARCH_LIMIT,
-        pre_prune_factor_tables: bool = True,
+        pre_prune_factor_tables: bool = False,
 ) -> PGMCircuit:
     """
     Compile the PGM to an arithmetic circuit, using factor elimination.
@@ -60,7 +60,7 @@ def compile_pgm_best_jointree(
         const_parameters: bool = True,
         *,
         limit_product_tree_search: int = DEFAULT_PRODUCT_SEARCH_LIMIT,
-        pre_prune_factor_tables: bool = True,
+        pre_prune_factor_tables: bool = False,
 ) -> PGMCircuit:
     """
     Try multiple elimination heuristics, and use the join tree that has
@@ -114,7 +114,7 @@ def join_tree_to_circuit(
         join_tree: JoinTree,
         const_parameters: bool = True,
         limit_product_tree_search: int = DEFAULT_PRODUCT_SEARCH_LIMIT,
-        pre_prune_factor_tables: bool = True,
+        pre_prune_factor_tables: bool = False,
 ) -> PGMCircuit:
     """
     Construct a PGMCircuit from a join-tree.