Repository: AUTODIAL/AutoEIS (language: python)

Issue:
Migrate to JuliaCall from PyJulia
PyJulia has caused so much trouble and pain. Fixes #13 


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/conda.yml b/.github/workflows/conda.yml
new file mode 100644
index 00000000..741dfd5f
--- /dev/null
+++ b/.github/workflows/conda.yml
@@ -0,0 +1,27 @@
+name: Conda
+
+on: pull_request
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Set up Python"
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          python-version: '3.10'
+          miniforge-version: latest
+      - name: "Install AutoEIS"
+        run: |
+            python -m pip install --upgrade pip
+            pip install -e .[test]
+            # Test that Julia + deps are automatically installed on first import
+            python -c "import autoeis"
+      - name: "Run tests"
+        run: |
+          pytest -v tests/
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index 2fc22a08..624550d8 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -46,4 +46,4 @@ jobs:
       - name: "Run tests"
         if: ${{ matrix.os != 'windows-latest' || matrix.python-version != '3.9' }}
         run: |
-          pytest -v .
+          pytest -v tests/
diff --git a/.github/workflows/notebooks.yml b/.github/workflows/notebooks.yml
index 75f69556..6c497dd1 100644
--- a/.github/workflows/notebooks.yml
+++ b/.github/workflows/notebooks.yml
@@ -12,7 +12,7 @@ jobs:
       matrix:
         julia-version: ['1.10']
         python-version: ['3.10']
-        os: [ubuntu-latest]
+        os: [macos-14]
 
     steps:
       - uses: actions/checkout@v4
@@ -37,4 +37,4 @@ jobs:
             python -m autoeis install
       - name: "Run tests"
         run: |
-          pytest -v --nbmake examples/*.ipynb
+          pytest -v --nbmake --nbmake-timeout=3600 examples/*.ipynb
diff --git a/autoeis/__init__.py b/autoeis/__init__.py
index b824c456..d373c120 100644
--- a/autoeis/__init__.py
+++ b/autoeis/__init__.py
@@ -1,4 +1,4 @@
-from . import core, io, metrics, parser, utils, visualization  # noqa: F401
-from .core import *
-from .version import __equivalent_circuits_jl_version__, __version__  # noqa: F401
-from .visualization import rich_print  # noqa: F401
+from . import core, io, metrics, parser, utils, visualization  # noqa: F401, E402
+from .core import *  # noqa: E402
+from .version import __equivalent_circuits_jl_version__, __version__  # noqa: F401, E402
+from .visualization import rich_print  # noqa: F401, E402
diff --git a/autoeis/cli.py b/autoeis/cli.py
index bb8f4ee1..803ac777 100644
--- a/autoeis/cli.py
+++ b/autoeis/cli.py
@@ -1,6 +1,6 @@
 import click
 
-from autoeis.julia_helpers import install
+from .julia_helpers import install_backend, install_julia
 
 
 @click.group("autoeis")
@@ -9,30 +9,13 @@ def autoeis_installer(context):
     ctx = context
 
 
-@autoeis_installer.command("install", help="Install Julia dependencies for AutoEIS.")
 @click.option(
-    "-p",
-    "julia_project",
-    "--project",
+    "--ec-path",
     default=None,
     type=str,
-    help="Install in a specific Julia project (e.g., a local copy of EquivalentProject.jl).",
-    metavar="PROJECT_DIRECTORY",
-)
-@click.option("-q", "--quiet", is_flag=True, default=False, help="Disable logging.")
-@click.option(
-    "--precompile",
-    "precompile",
-    flag_value=True,
-    default=None,
-    help="Force precompilation of Julia libraries.",
+    help="Installs a local copy of EquivalentCircuits instead of the remote version.",
 )
-@click.option(
-    "--no-precompile",
-    "precompile",
-    flag_value=False,
-    default=None,
-    help="Disable precompilation.",
-)
-def install_cli(julia_project, quiet, precompile):
-    install(julia_project=julia_project, quiet=quiet, precompile=precompile)
+@autoeis_installer.command("install", help="Install Julia dependencies for AutoEIS.")
+def install_cli(ec_path):
+    install_julia()
+    install_backend(ec_path=ec_path)
diff --git a/autoeis/cli_pyjulia.py b/autoeis/cli_pyjulia.py
new file mode 100644
index 00000000..bb8f4ee1
--- /dev/null
+++ b/autoeis/cli_pyjulia.py
@@ -0,0 +1,38 @@
+import click
+
+from autoeis.julia_helpers import install
+
+
+@click.group("autoeis")
+@click.pass_context
+def autoeis_installer(context):
+    ctx = context
+
+
+@autoeis_installer.command("install", help="Install Julia dependencies for AutoEIS.")
+@click.option(
+    "-p",
+    "julia_project",
+    "--project",
+    default=None,
+    type=str,
+    help="Install in a specific Julia project (e.g., a local copy of EquivalentProject.jl).",
+    metavar="PROJECT_DIRECTORY",
+)
+@click.option("-q", "--quiet", is_flag=True, default=False, help="Disable logging.")
+@click.option(
+    "--precompile",
+    "precompile",
+    flag_value=True,
+    default=None,
+    help="Force precompilation of Julia libraries.",
+)
+@click.option(
+    "--no-precompile",
+    "precompile",
+    flag_value=False,
+    default=None,
+    help="Disable precompilation.",
+)
+def install_cli(julia_project, quiet, precompile):
+    install(julia_project=julia_project, quiet=quiet, precompile=precompile)
diff --git a/autoeis/core.py b/autoeis/core.py
index b8ea2f51..a85ee70d 100644
--- a/autoeis/core.py
+++ b/autoeis/core.py
@@ -10,12 +10,10 @@
     generate_equivalent_circuits
     filter_implausible_circuits
     perform_bayesian_inference
-    perform_bayesian_inference_batch
-    preprocess_impedance_data 
+    preprocess_impedance_data
 
 """
 import os
-import sys
 import time
 import warnings
 from typing import Union
@@ -32,19 +30,22 @@
 from scipy.optimize import curve_fit
 from tqdm.auto import tqdm
 
-import autoeis.julia_helpers as julia_helpers
 import autoeis.visualization as viz
-from autoeis import io, metrics, parser, utils
+from autoeis import io, julia_helpers, metrics, parser, utils
 from autoeis.models import circuit_regression, circuit_regression_wrapped  # noqa: F401
 
 # AutoEIS datasets are not small-enough that CPU is much faster than GPU
 numpyro.set_platform("cpu")
 
 # HACK: Suppress output until ECSHackWeek/impedance.py/issues/280 is fixed
-linKK = utils.suppress_output(linKK)
+linKK = utils.suppress_output_legacy(linKK)
 warnings.filterwarnings("ignore", category=Warning, module="arviz.*")
 log = utils.get_logger(__name__)
 
+# Initialize Julia runtime
+julia_helpers.ensure_julia_deps_ready()
+jl = julia_helpers.init_julia()
+ec = julia_helpers.import_backend(jl)
 
 __all__ = [
     "perform_full_analysis",
@@ -225,9 +226,7 @@ def preprocess_impedance_data(
             ohmic_resistance = compute_ohmic_resistance(Z_mask, freq_mask)
             ohmic_resistance_found = True
         except ValueError:
-            log.error(
-                "Ohmic resistance not found. Check data or increase KK threshold."
-            )
+            log.error("Ohmic resistance not found. Check data or increase KK threshold.")
             ohmic_resistance_found = False
 
         # Convert the data to a dataframe for easier manipulation
@@ -303,22 +302,19 @@ def generate_equivalent_circuits(
     ecm_generator = _generate_ecm_parallel_julia if parallel else _generate_ecm_serial
     circuits = ecm_generator(impedance, freq, iters, ec_kwargs, seed)
 
-    # Convert Parameters column to dict, e.g., (R1 = 1.0, etc.) -> {"R1": 1.0, etc.}
+    # Convert output to DataFrame with columns ("circuitstring", "Parameters")
     circuits = io.parse_ec_output(circuits)
 
     if not len(circuits):
-        log.warning("No plausible circuits found. Try increasing `iters`.")
+        log.warning("No plausible circuits found. Increase `iters` or lower `tol`.")
 
     return circuits
 
 
-def _generate_ecm_serial(impedance, freq, iters, ec_kwargs, seed):
+def _generate_ecm_serial(impedance, freq, iters, ec_kwargs, seed) -> list[str]:
     """Generates candidate circuits in serial."""
-    Main = julia_helpers.init_julia()
-    ec = julia_helpers.import_backend(Main)
-
     # Set random seed for reproducibility
-    Main.eval(f"import Random; Random.seed!({seed})")
+    jl.seval(f"import Random; Random.seed!({seed})")
 
     circuits = []
     for _ in tqdm(range(iters), desc="Circuit Evolution"):
@@ -327,14 +323,10 @@ def _generate_ecm_serial(impedance, freq, iters, ec_kwargs, seed):
         except Exception as e:
             log.error(f"Error generating circuit: {e}")
             continue
-        if circuit != Main.nothing:
-            circuits.append(circuit)
-
-    # Format circuits as a dataframe with columns "circuitstring" and "Parameters"
-    df = [(c.circuitstring, Main.string(c.Parameters)) for c in circuits]
-    df = pd.DataFrame(df, columns=["circuitstring", "Parameters"])
+        circuits.append(circuit)
 
-    return df
+    circuits = [str(c) for c in circuits if c is not None]
+    return circuits
 
 
 # TODO: This function is deprecated, use _generate_ecm_parallel_julia instead
@@ -343,19 +335,18 @@ def _generate_ecm_parallel_mpire(impedance, freq, iters, ec_kwargs, seed):
 
     def circuit_evolution(seed: int):
         """Closure to generate a single circuit to be used with multiprocessing."""
-        Main = julia_helpers.init_julia()
+        jl = julia_helpers.init_julia()
+        ec = julia_helpers.import_backend(jl)
         # Set random seed for reproducibility
-        Main.eval(f"import Random; Random.seed!({seed})")
-        ec = julia_helpers.import_backend(Main)
+        jl.seval(f"import Random; Random.seed!({seed})")
         try:
             circuit = ec.circuit_evolution(impedance, freq, **ec_kwargs)
         except Exception as e:
             log.error(f"Error generating circuit: {e}")
             return None
-        if circuit == Main.nothing:
-            return None
-        # Format output as list of strings since Julia objects cannot be pickled
-        return [circuit.circuitstring, Main.string(circuit.Parameters)]
+        # # Format output as list of strings since Julia objects cannot be pickled
+        # return [circuit.circuitstring, jl.string(circuit.Parameters)]
+        return circuit
 
     nproc = os.cpu_count()
     mpire_kwargs = {
@@ -378,33 +369,23 @@ def circuit_evolution(seed: int):
             runtime_error = True
 
     if runtime_error:
-        raise RuntimeError(
-            "Julia must not be manually initialized, restart the kernel."
-        )
-
-    # Remove None values
-    circuits = [circuit for circuit in circuits if circuit is not None]
+        raise RuntimeError("Julia must not be manually initialized, restart the kernel.")
 
-    # Format circuits as a dataframe with columns "circuitstring" and "Parameters"
-    df = pd.DataFrame(circuits, columns=["circuitstring", "Parameters"])
-
-    return df
+    circuits = [str(c) for c in circuits if c is not None]
+    return circuits
 
 
 def _generate_ecm_parallel_julia(impedance, freq, iters, ec_kwargs, seed):
     """Generates candidate circuits in parallel using Julia multiprocessing."""
-    Main = julia_helpers.init_julia()
     # Set random seed for reproducibility (Python and Julia)
     # FIXME: This doesn't work when multiprocessing, use @everywhere instead
-    Main.eval(f"import Random; Random.seed!({seed})")
-    Main.eval("import Logging; Logging.disable_logging(Logging.Warn)")
-    ec = julia_helpers.import_backend(Main)
+    jl.seval(f"import Random; Random.seed!({seed})")
 
     # HACK: To get a progress bar, chunk the iterations -> call Julia repeatedly
     nprocs = psutil.cpu_count(logical=False)
     # Double the number of workers to buffer for those with slow convergence
     # (don't do this for small iters, otherwise progress bar becomes pointless)
-    nprocs = 2*nprocs if (iters // nprocs) > 10 else nprocs
+    nprocs = 2 * nprocs if (iters // nprocs) > 10 else nprocs
     # NOTE: e.g., iters = 11, nprocs = 4 -> iters_chunked = [4, 4, 3]
     iters_chunked = [nprocs] * (iters // nprocs)
     if iters % nprocs:
@@ -414,31 +395,19 @@ def _generate_ecm_parallel_julia(impedance, freq, iters, ec_kwargs, seed):
     circuits = []
 
     with tqdm(total=iters, desc="Circuit Evolution", miniters=1) as pbar:
-        # HACK: Flush once for progress bar to show up
-        sys.stderr.flush()
         for iters_ in iters_chunked:
             try:
                 circuits_ = ec.circuit_evolution_batch(
-                    impedance, freq, **ec_kwargs, iters=iters_
+                    impedance, freq, **ec_kwargs, iters=iters_, quiet=True
                 )
             except Exception as e:
                 log.error(f"Error generating circuits: {e}")
                 circuits_ = []
             circuits += circuits_
             pbar.update(iters_)
-            # HACK: Flush every iteration to refresh progress bar
-            sys.stderr.flush()
-
-    # Format output as list of strings since Julia objects cannot be pickled
-    circuits_py = []
-    for circuit in circuits:
-        if circuit != Main.nothing:
-            circuits_py.append([circuit.circuitstring, Main.string(circuit.Parameters)])
 
-    # Format circuits as a dataframe with columns "circuitstring" and "Parameters"
-    df = pd.DataFrame(circuits_py, columns=["circuitstring", "Parameters"])
-
-    return df
+    circuits = [str(c) for c in circuits if c is not None]
+    return circuits
 
 
 def split_components(circuits: pd.DataFrame) -> pd.DataFrame:
@@ -703,7 +672,7 @@ def _perform_bayesian_inference_batch(
             _perform_bayesian_inference,
             zip(*bi_kwargs.values()),
             progress_bar=progress_bar,
-            progress_bar_style="notebook",
+            progress_bar_style="notebook" if utils.is_notebook() else "rich",
             iterable_len=len(circuits),
         )
 
diff --git a/autoeis/io.py b/autoeis/io.py
index 308e8339..482b94b1 100644
--- a/autoeis/io.py
+++ b/autoeis/io.py
@@ -13,6 +13,7 @@
 
 """
 import os
+import re
 from pathlib import Path
 
 import numpy as np
@@ -51,21 +52,20 @@ def load_test_circuits(filtered=False) -> pd.DataFrame:
     return circuits
 
 
-def parse_ec_output(circuits: pd.DataFrame) -> pd.DataFrame:
-    """
-    Parses the output of EquivalentCircuits.jl's ``circuit_evolution``
-    and returns a dataframe with circuit parameters stored as dict[str, float].
-    """
-    circuits = circuits.copy()
+def parse_ec_output(circuits: list[str]) -> list[tuple[str, dict[str, float]]]:
+    """Parses the output of EquivalentCircuits.jl's ``circuit_evolution``."""
+    # Example: 'EquivalentCircuit("R1", (R1 = 1.0,))' -> ('R1', {'R1': 1.0})
+    circuits = [circuits] if isinstance(circuits, str) else circuits
+    parsed = []
 
-    for row in circuits.itertuples():
-        pstr = row.Parameters
-        # Remove parentheses and spaces, then split by comma -> list[var=val, ...]
-        pstr = pstr.strip("()").replace(" ", "")
-        pstr = pstr.split(",")
-        # Extract variable names and values into a dictionary
-        pdict = {pair.split("=")[0]: float(pair.split("=")[1]) for pair in pstr}
-        # Replace the stringified list with a proper dict
-        circuits.at[row.Index, "Parameters"] = pdict
+    for circuit in circuits:
+        circuit = circuit.removeprefix("EquivalentCircuit(").removesuffix(")")
+        cstr = re.findall(r"\"(.*?)\"", circuit)[0]
+        pstr = re.findall(r"\((.*?)\)", circuit)[0]
+        # NOTE: rstrip(",") to account for the trailing comma in one-element tuples
+        pstr = pstr.replace(" ", "").rstrip(",").split(",")
+        pdict = dict(pair.split("=") for pair in pstr)
+        pdict = {p.split("=")[0]: float(p.split("=")[1]) for p in pstr}
+        parsed.append([cstr, pdict])
 
-    return circuits
+    return pd.DataFrame(parsed, columns=["circuitstring", "Parameters"])
diff --git a/autoeis/julia_helpers.py b/autoeis/julia_helpers.py
index bcbdcfcb..442b9488 100644
--- a/autoeis/julia_helpers.py
+++ b/autoeis/julia_helpers.py
@@ -1,368 +1,99 @@
-# This code is based on the file julia_helpers.py from the PySR project.
-# It has been adapted to suit the requirements of AutoEIS.
-# The original file is under the Apache 2.0 license.
-# Acknowledge the original authors and license when utilizing this code.
-# Original repository: https://github.com/MilesCranmer/PySR
-# Commit reference: 976f8d8 dated 2023-09-16.
+import juliapkg
+from juliapkg.find_julia import ju_find_julia_noinstall
 
-import importlib
-import os
-import subprocess
-import sys
-from pathlib import Path
+from .utils import get_logger, suppress_output
+from .version import __equivalent_circuits_jl_version__
 
-from julia.api import JuliaError
+log = get_logger(__name__)
 
-import autoeis.utils as utils
 
-from .version import __equivalent_circuits_jl_version__, __version__
+def install_julia():
+    """Installs Julia using juliapkg."""
+    # Importing juliacall automatically installs Julia using juliapkg
+    import juliacall
 
-MAX_RETRIES = 2
-juliainfo = None
-julia_initialized = False
-julia_kwargs_at_initialization = None
-julia_activated_env = None
 
-log = utils.get_logger(__name__)
-# TODO: For virtualenvs see https://github.com/JuliaPy/PyCall.jl?tab=readme-ov-file#python-virtual-environments
+def install_backend(ec_path=None):
+    """Installs Julia dependencies for AutoEIS."""
+    is_julia_installed(error=True)
 
-
-def install(julia_project=None, quiet=False, precompile=None, offline=False):  # pragma: no cover
-    """Install all required dependencies for EquivalentCircuits.jl."""
-    import julia
-
-    _julia_version_assertion()
-    # Set JULIA_PROJECT so that we install in the autoeis environment
-    processed_julia_project, is_shared = _process_julia_project(julia_project)
-    _set_julia_project_env(processed_julia_project, is_shared)
-
-    if precompile == False:
-        os.environ["JULIA_PKG_PRECOMPILE_AUTO"] = "0"
-    
-    if offline:
-        os.environ["JULIA_PKG_OFFLINE"] = "true"
-
-    try:
-        julia.install(quiet=quiet)
-    except julia.tools.PyCallInstallError:
-        # Attempt to reset PyCall.jl's build:
-        subprocess.run(
-            [
-                "julia",
-                "-e",
-                f'ENV["PYTHON"] = "{sys.executable}"; import Pkg; Pkg.build("PyCall")',
-            ],
-        )
-        # Try installing again:
-        julia.install(quiet=quiet)
-
-    Main, init_log = init_julia(julia_project, quiet=quiet, return_aux=True)
-    io_arg = _get_io_arg(quiet)
-
-    if precompile is None:
-        precompile = init_log["compiled_modules"]
-
-    if not precompile:
-        Main.eval('ENV["JULIA_PKG_PRECOMPILE_AUTO"] = 0')
-
-    if is_shared:
-        # Install EquivalentCircuits.jl:
-        _add_ec_to_julia_project(Main, io_arg)
-
-    Main.eval("using Pkg")
-    Main.eval(f"Pkg.instantiate({io_arg})")
-
-    if precompile:
-        Main.eval(f"Pkg.precompile({io_arg})")
-
-    if not quiet:
-        log.warning(
-            "It is recommended to restart Python after installing AutoEIS "
-            "dependencies, so that the Julia environment is properly initialized."
-        )
-
-
-def init_julia(julia_project=None, quiet=False, julia_kwargs=None, return_aux=False):
-    """Initialize julia binary, turning off compiled modules if needed."""
-    global julia_initialized
-    global julia_kwargs_at_initialization
-    global julia_activated_env
-
-    if julia_kwargs is None:
-        julia_kwargs = {"optimize": 3}
-
-    from julia.core import JuliaInfo, UnsupportedPythonError
-
-    _julia_version_assertion()
-    processed_julia_project, is_shared = _process_julia_project(julia_project)
-    _set_julia_project_env(processed_julia_project, is_shared)
-
-    try:
-        info = JuliaInfo.load(julia="julia")
-    except FileNotFoundError:
-        _raise_julia_not_found()
-
-    if not info.is_pycall_built():
-        _raise_import_error()
-
-    from julia.core import Julia
-
-    try:
-        Julia(**julia_kwargs)
-    except UnsupportedPythonError:
-        # HACK: When switching virtualenvs, we also get UnsupportedPythonError.
-        # Check if it resolves by recompiling PyCall, if not turn off compiled_modules
-        _recompile_pycall()
-        try:
-            Julia(**julia_kwargs)
-        except UnsupportedPythonError:
-            # Static python binary, so we turn off pre-compiled modules.
-            julia_kwargs = {**julia_kwargs, "compiled_modules": False}
-            Julia(**julia_kwargs)
-            log.warning(
-                "Your system's Python library is static (e.g., conda), "
-                "so precompilation will be turned off. For a dynamic library, "
-                "try using `pyenv` and installing with `--enable-shared`: "
-                "https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md"
-            )
-
-    using_compiled_modules = (not "compiled_modules" in julia_kwargs) or julia_kwargs[
-        "compiled_modules"
-    ]
-
-    from julia import Main as _Main
-
-    Main = _Main
-
-    if julia_activated_env is None:
-        julia_activated_env = processed_julia_project
-
-    if julia_initialized and julia_kwargs_at_initialization is not None:
-        # Check if the kwargs are the same as the previous initialization
-        init_set = set(julia_kwargs_at_initialization.items())
-        new_set = set(julia_kwargs.items())
-        set_diff = new_set - init_set
-        # Remove the `compiled_modules` key, since it is not a user-specified kwarg:
-        set_diff = {k: v for k, v in set_diff if k != "compiled_modules"}
-        if len(set_diff) > 0:
-            log.warning(
-                f"Julia has already started. The new Julia options {set_diff} "
-                "will be ignored."
-            )
-
-    if julia_initialized and julia_activated_env != processed_julia_project:
-        Main.eval("using Pkg")
-
-        io_arg = _get_io_arg(quiet)
-        # Can't pass IO to Julia call as it evaluates to PyObject, so just directly
-        # use Main.eval:
-        Main.eval(
-            f'Pkg.activate("{_escape_filename(processed_julia_project)}",'
-            f"shared = Bool({int(is_shared)}), "
-            f"{io_arg})"
-        )
-
-        julia_activated_env = processed_julia_project
-
-    if not julia_initialized:
-        julia_kwargs_at_initialization = julia_kwargs
-
-    julia_initialized = True
-    if return_aux:
-        return Main, {"compiled_modules": using_compiled_modules}
-    return Main
-
-
-def import_backend(Main=None):
-    """Load EquivalentCircuits.jl, verify version and return a reference."""
-    if Main is None:
-        Main = init_julia()
-    ec = import_package("EquivalentCircuits", Main=Main)
-    # FIXME: Currently don't know how to assert branch name if installed from GitHub
-    if __equivalent_circuits_jl_version__.startswith("v"):
-        _backend_version_assertion(Main)
-    return ec
-
-
-def import_package(pkg_name, Main=None):
-    """Load a Julia package and return a reference to it."""
-    if Main is None:
-        Main = init_julia()
-    # HACK: On Windows, for som reason, the first two imports fail!        
-    for _ in range(MAX_RETRIES):
-        try:
-            Main.eval(f"using {pkg_name}")
-        except Exception:
-            pass
-    # Now, normally import the package
-    try:
-        Main.eval(f"using {pkg_name}")
-    except (JuliaError, RuntimeError) as e:
-        _raise_import_error(root=e)
-    ref = importlib.import_module(f"julia.{pkg_name}")
-    return ref
-
-
-def add_to_path(path):
-    if not os.path.exists(path):
-        raise ValueError(f"The provided path '{path}' does not exist.")
-    
-    if path not in os.environ["PATH"].split(os.pathsep):
-        os.environ["PATH"] += os.pathsep + path
-
-
-def _recompile_pycall():
-    import julia
-    try:
-        os.environ["PYCALL_JL_RUNTIME_PYTHON"] = sys.executable
-        julia.install(quiet=True)
-    except julia.tools.PyCallInstallError:
-        pass    
-
-
-def _raise_import_error(root: Exception=None):
-    """Raise ImportError if Julia dependencies are not installed."""
-    raise ImportError(
-        "Required dependencies are not installed or built. Run the "
-        "following command: import autoeis; autoeis.julia_helpers.install()."
-    ) from root
-
-
-def _raise_julia_not_found(root: Exception=None):
-    """Raise FileNotFoundError if Julia is not installed."""
-    raise FileNotFoundError(
-        "Julia is not installed in your PATH. Please install Julia "
-        "and add it to your PATH."
-    ) from root
-
-
-def _load_juliainfo():
-    """Execute julia.core.JuliaInfo.load(), and store as juliainfo."""
-    global juliainfo
-
-    if juliainfo is None:
-        from julia.core import JuliaInfo
-
-        try:
-            juliainfo = JuliaInfo.load(julia="julia")
-        except FileNotFoundError:
-            _raise_julia_not_found()
-
-    return juliainfo
-
-
-def _get_julia_env_dir():
-    """Find the Julia environments' directory."""
-    try:
-        julia_env_dir_str = subprocess.run(
-            ["julia", "-e using Pkg; print(Pkg.envdir())"],
-            capture_output=True,
-            env=os.environ,
-        ).stdout.decode()
-    except FileNotFoundError:
-        env_path = os.environ["PATH"]
-        _raise_julia_not_found()
-    return Path(julia_env_dir_str)
-
-
-def _set_julia_project_env(julia_project, is_shared):
-    """Set JULIA_PROJECT environment variable."""
-    if is_shared:
-        if _is_julia_version_greater_eq(version=(1, 7, 0)):
-            os.environ["JULIA_PROJECT"] = "@" + str(julia_project)
-        else:
-            julia_env_dir = _get_julia_env_dir()
-            os.environ["JULIA_PROJECT"] = str(julia_env_dir / julia_project)
-    else:
-        os.environ["JULIA_PROJECT"] = str(julia_project)
-
-
-def _get_io_arg(quiet):
-    """Return Julia-compatible IO arg that suppresses output if quiet=True."""
-    io = "devnull" if quiet else "stderr"
-    io_arg = f"io={io}" if _is_julia_version_greater_eq(version=(1, 6, 0)) else ""
-    return io_arg
-
-
-def _process_julia_project(julia_project):
-    if julia_project is None:
-        is_shared = True
-        processed_julia_project = f"autoeis-{__version__}"
-    elif julia_project[0] == "@":
-        is_shared = True
-        processed_julia_project = julia_project[1:]
+    kwargs = {"name": "EquivalentCircuits", "uuid": "da5bd070-f609-4e16-a30d-de86b3faa756"}
+    if ec_path is not None:
+        kwargs["path"] = ec_path
+        kwargs["dev"] = True
     else:
-        is_shared = False
-        processed_julia_project = Path(julia_project)
-    return processed_julia_project, is_shared
-
-
-def _is_julia_version_greater_eq(juliainfo=None, version=(1, 6, 0)):
-    """Check if Julia version is greater than specified version."""
-    if juliainfo is None:
-        juliainfo = _load_juliainfo()
-    current_version = (
-        juliainfo.version_major,
-        juliainfo.version_minor,
-        juliainfo.version_patch,
-    )
-    return current_version >= version
-
-
-def _add_ec_to_julia_project(Main, io_arg):
-    """Install EquivalentCircuits.jl and dependencies to the Julia project."""
-    Main.eval("using Pkg")
-    Main.eval(f"Pkg.Registry.update({io_arg})")
-    kwargs = {"name": "EquivalentCircuits"}
-    if __equivalent_circuits_jl_version__.startswith("v"):
-        kwargs["version"] = __equivalent_circuits_jl_version__
-    else:
-        kwargs["rev"] = __equivalent_circuits_jl_version__
-    Main.ec_spec = Main.PackageSpec(**kwargs)
-    Main.eval(f"Pkg.add([ec_spec], {io_arg})")
+        if __equivalent_circuits_jl_version__.startswith("v"):
+            kwargs["version"] = __equivalent_circuits_jl_version__
+        else:
+            kwargs["rev"] = __equivalent_circuits_jl_version__
+            kwargs["url"] = "https://github.com/ma-sadeghi/EquivalentCircuits.jl"
+    pkg_spec = juliapkg.PkgSpec(**kwargs)
+    juliapkg.add(pkg_spec)
+    juliapkg.resolve()
 
 
-def _escape_filename(filename):
-    """Turn a path into a string with correctly escaped backslashes."""
-    str_repr = str(filename)
-    str_repr = str_repr.replace("\\", "\\\\")
-    return str_repr
+def init_julia():
+    """Initializes Julia and returns the Main module."""
+    is_julia_installed(error=True, install=False)
+    from juliacall import Main
 
+    return Main
 
-def _julia_version_assertion():
-    """Check if Julia version is greater than 1.9"""
-    if not _is_julia_version_greater_eq(version=(1, 9, 0)):
-        raise NotImplementedError(
-            "AutoEIS requires Julia 1.9.0 or greater. "
-            "Please update your Julia installation."
-        )
 
+def import_package(package_name, Main, error=False):
+    """Imports a package in Julia and returns the module."""
+    from juliacall import JuliaError
 
-def _backend_version_assertion(Main):
-    """Check if EquivalentCircuits.jl version is correct."""
     try:
-        backend_version = Main.eval("string(pkgversion(EquivalentCircuits))")
-        expected_backend_version = __equivalent_circuits_jl_version__
-        if backend_version != expected_backend_version:  # pragma: no cover
-            log.warning(
-                f"AutoEIS backend (EquivalentCircuits.jl) version {backend_version} "
-                f"does not match expected version {expected_backend_version}. "
-                "Things may break. Please update your AutoEIS installation with "
-                "`import autoeis; autoeis.julia_helpers.install()`."
-            )
-    except JuliaError:  # pragma: no cover
-        log.warning(
-            "You seem to have an outdated version of EquivalentCircuits.jl. "
-            "Things may break. Please update your AutoEIS installation with "
-            "`import autoeis; autoeis.julia_helpers.install()`."
-        )
+        Main.seval(f"using {package_name}")
+        return eval(f"Main.{package_name}")
+    except JuliaError as e:
+        if error:
+            raise e
+    return None
 
 
-def _update_julia_project(Main, is_shared, io_arg):
-    try:
-        if is_shared:
-            _add_ec_to_julia_project(Main, io_arg)
-        Main.eval("using Pkg")
-        Main.eval(f"Pkg.resolve({io_arg})")
-    except (JuliaError, RuntimeError) as e:
-        _raise_import_error(root=e)
+def import_backend(Main=None):
+    """Imports EquivalentCircuits package from Julia."""
+    Main = init_julia() if Main is None else Main
+    is_backend_installed(error=True, install=False)
+    return import_package("EquivalentCircuits", Main)
+
+
+def is_julia_installed(error=False, install=False):
+    """Asserts that Julia is installed."""
+    julia_installed_sys = ju_find_julia_noinstall()
+    julia_installed_exe = juliapkg.deps.can_skip_resolve()
+    if julia_installed_sys or julia_installed_exe:
+        return True
+    if install:
+        log.warning("Julia not found, installing Julia...")
+        with suppress_output():
+            install_julia()
+        return True
+    msg = "Julia not found. Visit https://github.com/JuliaLang/juliaup and install Julia."
+    if error:
+        raise ImportError(msg)
+    return False
+
+
+def is_backend_installed(Main=None, error=False, install=False):
+    """Asserts that EquivalentCircuits.jl is installed."""
+    Main = init_julia() if Main is None else Main
+    if import_package("EquivalentCircuits", Main, error=False) is not None:
+        return True
+    if install:
+        log.warning("EquivalentCircuits.jl not found, installing...")
+        with suppress_output():
+            install_backend()
+        return True
+    msg = "EquivalentCircuits.jl not found, run 'python -m autoeis install'"
+    if error:
+        raise ImportError(msg)
+    return False
+
+
+def ensure_julia_deps_ready():
+    """Ensures Julia and EquivalentCircuits.jl are installed."""
+    is_julia_installed(error=True, install=True)
+    is_backend_installed(error=True, install=True)
diff --git a/autoeis/julia_helpers_pyjulia.py b/autoeis/julia_helpers_pyjulia.py
new file mode 100644
index 00000000..cb426791
--- /dev/null
+++ b/autoeis/julia_helpers_pyjulia.py
@@ -0,0 +1,368 @@
+# This code is based on the file julia_helpers.py from the PySR project.
+# It has been adapted to suit the requirements of AutoEIS.
+# The original file is under the Apache 2.0 license.
+# Acknowledge the original authors and license when utilizing this code.
+# Original repository: https://github.com/MilesCranmer/PySR
+# Commit reference: 976f8d8 dated 2023-09-16.
+
+import importlib
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from julia.api import JuliaError
+
+import autoeis.utils as utils
+
+from .version import __equivalent_circuits_jl_version__, __version__
+
+MAX_RETRIES = 2
+juliainfo = None
+julia_initialized = False
+julia_kwargs_at_initialization = None
+julia_activated_env = None
+
+log = utils.get_logger(__name__)
+# TODO: For virtualenvs see https://github.com/JuliaPy/PyCall.jl?tab=readme-ov-file#python-virtual-environments
+
+
+def install(
+    julia_project=None, quiet=False, precompile=None, offline=False
+):  # pragma: no cover
+    """Install all required dependencies for EquivalentCircuits.jl."""
+    import julia
+
+    _julia_version_assertion()
+    # Set JULIA_PROJECT so that we install in the autoeis environment
+    processed_julia_project, is_shared = _process_julia_project(julia_project)
+    _set_julia_project_env(processed_julia_project, is_shared)
+
+    if precompile is False:
+        os.environ["JULIA_PKG_PRECOMPILE_AUTO"] = "0"
+
+    if offline:
+        os.environ["JULIA_PKG_OFFLINE"] = "true"
+
+    try:
+        julia.install(quiet=quiet)
+    except julia.tools.PyCallInstallError:
+        # Attempt to reset PyCall.jl's build:
+        subprocess.run(
+            [
+                "julia",
+                "-e",
+                f'ENV["PYTHON"] = "{sys.executable}"; import Pkg; Pkg.build("PyCall")',
+            ],
+        )
+        # Try installing again:
+        julia.install(quiet=quiet)
+
+    Main, init_log = init_julia(julia_project, quiet=quiet, return_aux=True)
+    io_arg = _get_io_arg(quiet)
+
+    if precompile is None:
+        precompile = init_log["compiled_modules"]
+
+    if not precompile:
+        Main.eval('ENV["JULIA_PKG_PRECOMPILE_AUTO"] = 0')
+
+    if is_shared:
+        # Install EquivalentCircuits.jl:
+        _add_ec_to_julia_project(Main, io_arg)
+
+    Main.eval("using Pkg")
+    Main.eval(f"Pkg.instantiate({io_arg})")
+
+    if precompile:
+        Main.eval(f"Pkg.precompile({io_arg})")
+
+    if not quiet:
+        log.warning(
+            "It is recommended to restart Python after installing AutoEIS "
+            "dependencies, so that the Julia environment is properly initialized."
+        )
+
+
+def init_julia(julia_project=None, quiet=False, julia_kwargs=None, return_aux=False):
+    """Initialize julia binary, turning off compiled modules if needed."""
+    global julia_initialized
+    global julia_kwargs_at_initialization
+    global julia_activated_env
+
+    if julia_kwargs is None:
+        julia_kwargs = {"optimize": 3}
+
+    from julia.core import JuliaInfo, UnsupportedPythonError
+
+    _julia_version_assertion()
+    processed_julia_project, is_shared = _process_julia_project(julia_project)
+    _set_julia_project_env(processed_julia_project, is_shared)
+
+    try:
+        info = JuliaInfo.load(julia="julia")
+    except FileNotFoundError:
+        _raise_julia_not_found()
+
+    if not info.is_pycall_built():
+        _raise_import_error()
+
+    from julia.core import Julia
+
+    try:
+        Julia(**julia_kwargs)
+    except UnsupportedPythonError:
+        # HACK: When switching virtualenvs, we also get UnsupportedPythonError.
+        # Check if it resolves by recompiling PyCall, if not turn off compiled_modules
+        _recompile_pycall()
+        try:
+            Julia(**julia_kwargs)
+        except UnsupportedPythonError:
+            # Static python binary, so we turn off pre-compiled modules.
+            julia_kwargs = {**julia_kwargs, "compiled_modules": False}
+            Julia(**julia_kwargs)
+            log.warning(
+                "Your system's Python library is static (e.g., conda), "
+                "so precompilation will be turned off. For a dynamic library, "
+                "try using `pyenv` and installing with `--enable-shared`: "
+                "https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md"
+            )
+
+    using_compiled_modules = ("compiled_modules" not in julia_kwargs) or julia_kwargs[
+        "compiled_modules"
+    ]
+
+    from julia import Main as _Main
+
+    Main = _Main
+
+    if julia_activated_env is None:
+        julia_activated_env = processed_julia_project
+
+    if julia_initialized and julia_kwargs_at_initialization is not None:
+        # Check if the kwargs are the same as the previous initialization
+        init_set = set(julia_kwargs_at_initialization.items())
+        new_set = set(julia_kwargs.items())
+        set_diff = new_set - init_set
+        # Remove the `compiled_modules` key, since it is not a user-specified kwarg:
+        set_diff = {k: v for k, v in set_diff if k != "compiled_modules"}
+        if len(set_diff) > 0:
+            log.warning(
+                f"Julia has already started. The new Julia options {set_diff} "
+                "will be ignored."
+            )
+
+    if julia_initialized and julia_activated_env != processed_julia_project:
+        Main.eval("using Pkg")
+
+        io_arg = _get_io_arg(quiet)
+        # Can't pass IO to Julia call as it evaluates to PyObject, so just directly
+        # use Main.eval:
+        Main.eval(
+            f'Pkg.activate("{_escape_filename(processed_julia_project)}",'
+            f"shared = Bool({int(is_shared)}), "
+            f"{io_arg})"
+        )
+
+        julia_activated_env = processed_julia_project
+
+    if not julia_initialized:
+        julia_kwargs_at_initialization = julia_kwargs
+
+    julia_initialized = True
+    if return_aux:
+        return Main, {"compiled_modules": using_compiled_modules}
+    return Main
+
+
+def import_backend(Main):
+    """Load EquivalentCircuits.jl, verify version and return a reference."""
+    ec = import_package("EquivalentCircuits", Main=Main)
+    # FIXME: Currently don't know how to assert branch name if installed from GitHub
+    if __equivalent_circuits_jl_version__.startswith("v"):
+        _backend_version_assertion(Main)
+    return ec
+
+
+def import_package(pkg_name, Main):
+    """Load a Julia package and return a reference to it."""
+    # HACK: On Windows, for some reason, the first two imports fail!
+    for _ in range(MAX_RETRIES):
+        try:
+            Main.eval(f"using {pkg_name}")
+            break
+        except Exception:
+            pass
+    else:
+        # Import failed, raise proper error
+        try:
+            Main.eval(f"using {pkg_name}")
+        except (JuliaError, RuntimeError) as e:
+            _raise_import_error(root=e)
+    return importlib.import_module(f"julia.{pkg_name}")
+
+
+def add_to_path(path):
+    if not os.path.exists(path):
+        raise ValueError(f"The provided path '{path}' does not exist.")
+
+    if path not in os.environ["PATH"].split(os.pathsep):
+        os.environ["PATH"] += os.pathsep + path
+
+
+def _recompile_pycall():
+    import julia
+
+    try:
+        os.environ["PYCALL_JL_RUNTIME_PYTHON"] = sys.executable
+        julia.install(quiet=True)
+    except julia.tools.PyCallInstallError:
+        pass
+
+
+def _raise_import_error(root: Exception = None):
+    """Raise ImportError if Julia dependencies are not installed."""
+    raise ImportError(
+        "Required dependencies are not installed or built. Run the "
+        "following command: import autoeis; autoeis.julia_helpers.install()."
+    ) from root
+
+
+def _raise_julia_not_found(root: Exception = None):
+    """Raise FileNotFoundError if Julia is not installed."""
+    raise FileNotFoundError(
+        "Julia is not installed in your PATH. Please install Julia "
+        "and add it to your PATH."
+    ) from root
+
+
+def _load_juliainfo():
+    """Execute julia.core.JuliaInfo.load(), and store as juliainfo."""
+    global juliainfo
+
+    if juliainfo is None:
+        from julia.core import JuliaInfo
+
+        try:
+            juliainfo = JuliaInfo.load(julia="julia")
+        except FileNotFoundError:
+            _raise_julia_not_found()
+
+    return juliainfo
+
+
+def _get_julia_env_dir():
+    """Find the Julia environments' directory."""
+    try:
+        julia_env_dir_str = subprocess.run(
+            ["julia", "-e using Pkg; print(Pkg.envdir())"],
+            capture_output=True,
+            env=os.environ,
+        ).stdout.decode()
+    except FileNotFoundError:
+        env_path = os.environ["PATH"]
+        _raise_julia_not_found()
+    return Path(julia_env_dir_str)
+
+
+def _set_julia_project_env(julia_project, is_shared):
+    """Set JULIA_PROJECT environment variable."""
+    if is_shared:
+        if _is_julia_version_greater_eq(version=(1, 7, 0)):
+            os.environ["JULIA_PROJECT"] = "@" + str(julia_project)
+        else:
+            julia_env_dir = _get_julia_env_dir()
+            os.environ["JULIA_PROJECT"] = str(julia_env_dir / julia_project)
+    else:
+        os.environ["JULIA_PROJECT"] = str(julia_project)
+
+
+def _get_io_arg(quiet):
+    """Return Julia-compatible IO arg that suppresses output if quiet=True."""
+    io = "devnull" if quiet else "stderr"
+    io_arg = f"io={io}" if _is_julia_version_greater_eq(version=(1, 6, 0)) else ""
+    return io_arg
+
+
+def _process_julia_project(julia_project):
+    if julia_project is None:
+        is_shared = True
+        processed_julia_project = f"autoeis-{__version__}"
+    elif julia_project[0] == "@":
+        is_shared = True
+        processed_julia_project = julia_project[1:]
+    else:
+        is_shared = False
+        processed_julia_project = Path(julia_project)
+    return processed_julia_project, is_shared
+
+
+def _is_julia_version_greater_eq(juliainfo=None, version=(1, 6, 0)):
+    """Check if Julia version is greater than specified version."""
+    if juliainfo is None:
+        juliainfo = _load_juliainfo()
+    current_version = (
+        juliainfo.version_major,
+        juliainfo.version_minor,
+        juliainfo.version_patch,
+    )
+    return current_version >= version
+
+
+def _add_ec_to_julia_project(Main, io_arg):
+    """Install EquivalentCircuits.jl and dependencies to the Julia project."""
+    Main.eval("using Pkg")
+    Main.eval(f"Pkg.Registry.update({io_arg})")
+    kwargs = {"name": "EquivalentCircuits"}
+    if __equivalent_circuits_jl_version__.startswith("v"):
+        kwargs["version"] = __equivalent_circuits_jl_version__
+    else:
+        kwargs["rev"] = __equivalent_circuits_jl_version__
+    Main.ec_spec = Main.PackageSpec(**kwargs)
+    Main.eval(f"Pkg.add([ec_spec], {io_arg})")
+
+
+def _escape_filename(filename):
+    """Turn a path into a string with correctly escaped backslashes."""
+    str_repr = str(filename)
+    str_repr = str_repr.replace("\\", "\\\\")
+    return str_repr
+
+
+def _julia_version_assertion():
+    """Check if Julia version is greater than 1.9"""
+    if not _is_julia_version_greater_eq(version=(1, 9, 0)):
+        raise NotImplementedError(
+            "AutoEIS requires Julia 1.9.0 or greater. "
+            "Please update your Julia installation."
+        )
+
+
+def _backend_version_assertion(Main):
+    """Check if EquivalentCircuits.jl version is correct."""
+    try:
+        backend_version = Main.eval("string(pkgversion(EquivalentCircuits))")
+        expected_backend_version = __equivalent_circuits_jl_version__
+        if backend_version != expected_backend_version:  # pragma: no cover
+            log.warning(
+                f"AutoEIS backend (EquivalentCircuits.jl) version {backend_version} "
+                f"does not match expected version {expected_backend_version}. "
+                "Things may break. Please update your AutoEIS installation with "
+                "`import autoeis; autoeis.julia_helpers.install()`."
+            )
+    except JuliaError:  # pragma: no cover
+        log.warning(
+            "You seem to have an outdated version of EquivalentCircuits.jl. "
+            "Things may break. Please update your AutoEIS installation with "
+            "`import autoeis; autoeis.julia_helpers.install()`."
+        )
+
+
+def _update_julia_project(Main, is_shared, io_arg):
+    try:
+        if is_shared:
+            _add_ec_to_julia_project(Main, io_arg)
+        Main.eval("using Pkg")
+        Main.eval(f"Pkg.resolve({io_arg})")
+    except (JuliaError, RuntimeError) as e:
+        _raise_import_error(root=e)
diff --git a/autoeis/utils.py b/autoeis/utils.py
index f874199a..315da415 100644
--- a/autoeis/utils.py
+++ b/autoeis/utils.py
@@ -22,6 +22,7 @@
 import signal
 import sys
 from collections.abc import Iterable
+from contextlib import contextmanager
 from functools import partial, wraps
 from typing import Union
 
@@ -36,13 +37,15 @@
 from scipy import stats
 
 # from tensorflow_probability import distributions as tfdist  # NOQA: F401
-from autoeis import parser
+import __main__
+
+from . import parser
 
 # >>> Logging utils
 
 
 def get_logger(name: str) -> logging.Logger:
-    """Get a logger with the given name."""
+    """Returns a logger with the given name."""
     logger = logging.getLogger(name)
     if logger.hasHandlers():
         # If logger has handlers, do not add another to avoid duplicate logs
@@ -102,8 +105,9 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         sys.stderr = self._original_stderr
 
 
-def suppress_output(func):
+def suppress_output_legacy(func):
     """Suppresses the output of a function."""
+    # NOTE: This approach only works when stdout/stderr are managed by Python
 
     @wraps(func)
     def wrapped(*args, **kwargs):
@@ -113,6 +117,28 @@ def wrapped(*args, **kwargs):
     return wrapped
 
 
+@contextmanager
+def suppress_output():
+    """Suppresses the output of a block of code using file descriptors."""
+    # NOTE: This approach is more system-level than suppress_output
+    # Save the current file descriptors
+    original_stderr_fd = os.dup(2)
+    original_stdout_fd = os.dup(1)
+
+    try:
+        # Use os.devnull to redirect the standard output and standard error
+        with open(os.devnull, "wb") as devnull:
+            os.dup2(devnull.fileno(), 1)
+            os.dup2(devnull.fileno(), 2)
+            yield
+    finally:
+        # Restore the original file descriptors
+        os.dup2(original_stdout_fd, 1)
+        os.dup2(original_stderr_fd, 2)
+        os.close(original_stdout_fd)
+        os.close(original_stderr_fd)
+
+
 class TimeoutException(Exception):
     pass
 
@@ -141,6 +167,36 @@ def wrapper(*args, **kwargs):
     return decorator
 
 
+# Source: https://discourse.jupyter.org/t/find-out-if-my-code-runs-inside-a-notebook-or-jupyter-lab/6935/21
+def get_runtime():
+    """Returns the runtime environment."""
+    if "google.colab" in sys.modules:
+        return "Google Colab"
+    elif "ipykernel" in sys.modules:
+        if "jupyter" in sys.modules:
+            return "JupyterLab"
+        else:
+            return "Jupyter Notebook"
+    elif "win32" in sys.platform:
+        if "CMDEXTVERSION" in os.environ:
+            return "Windows Command Prompt"
+        else:
+            return "Windows PowerShell"
+    elif "darwin" in sys.platform:
+        return "MacOS Terminal"
+    else:
+        if hasattr(__main__, "__file__"):
+            return "Linux Terminal"
+        else:
+            return "Interactive Python Shell"
+
+
+def is_notebook():
+    """Returns True if the code is running in a Jupyter notebook."""
+    runtime = get_runtime()
+    return runtime in ["Google Colab", "JupyterLab", "Jupyter Notebook"]
+
+
 # <<< General utils
 
 
diff --git a/autoeis/version.py b/autoeis/version.py
index 418f09d6..c0b23606 100644
--- a/autoeis/version.py
+++ b/autoeis/version.py
@@ -1,3 +1,3 @@
 __version__ = "0.0.23"
 # Either use a branch name or a tag name for EquivalentCircuits.jl
-__equivalent_circuits_jl_version__ = "master"  # "0.3.1"
+__equivalent_circuits_jl_version__ = "bug/fix-ndarray-serialization"  # "0.3.1"
diff --git a/examples/autoeis_demo.ipynb b/examples/autoeis_demo.ipynb
index 84c6d7af..ab22f12d 100644
--- a/examples/autoeis_demo.ipynb
+++ b/examples/autoeis_demo.ipynb
@@ -18,7 +18,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "AutoEIS relies on `EquivalentCircuits.jl` package to perform the EIS analysis. The package is not written in Python, so we need to install it first. AutoEIS ships with `julia_helpers` module that helps to install and manage Julia dependencies with minimal user interaction. The only thing you need to do is to run `autoeis.julia_helpers.install()`, and everything will be taken care of. You only need to do this once."
+    "AutoEIS relies on `EquivalentCircuits.jl` package to perform the EIS analysis. The package is not written in Python, so we need to install it first. AutoEIS ships with `julia_helpers` module that helps to install and manage Julia dependencies with minimal user interaction. For convenience, installing Julia and the required packages is done automatically when you import `autoeis` for the first time. If you have Julia installed already (discoverable in system PATH), it'll get detected and used, otherwise, it'll be installed automatically."
    ]
   },
   {
@@ -40,18 +40,11 @@
     "from IPython.display import display\n",
     "\n",
     "import autoeis as ae\n",
-    "from autoeis import julia_helpers\n",
     "\n",
     "ae.visualization.set_plot_style()\n",
     "\n",
     "# Set this to True if you're running the notebook locally\n",
-    "interactive = False\n",
-    "\n",
-    "# If Julia executable not in PATH, add it here (not needed if you use `juliaup` to install Julia)\n",
-    "# julia_helpers.add_to_PATH(PATH_TO_JULIA_BIN_DIR)\n",
-    "\n",
-    "# Uncomment this line if you are running the code for the first time\n",
-    "# julia_helpers.install()"
+    "interactive = False"
    ]
   },
   {
@@ -98,15 +91,15 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x300 with 3 Axes>"
       ]
      },
      "metadata": {
       "image/png": {
-       "height": 286,
-       "width": 780
+       "height": 287,
+       "width": 777
       }
      },
      "output_type": "display_data"
@@ -143,15 +136,15 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 500x350 with 1 Axes>"
       ]
      },
      "metadata": {
       "image/png": {
-       "height": 358,
-       "width": 472
+       "height": 355,
+       "width": 479
       }
      },
      "output_type": "display_data"
@@ -174,9 +167,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "af8bd6b94fae40e78dd6c5e3cc712d99",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Circuit Evolution:   0%|          | 0/24 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[ Info: Starting circuit evolution on 6 workers\n",
+      "[ Info: Starting circuit evolution on 6 workers\n",
+      "[ Info: Starting circuit evolution on 6 workers\n",
+      "[ Info: Starting circuit evolution on 6 workers\n"
+     ]
+    },
     {
      "data": {
       "text/html": [
@@ -205,107 +222,169 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>[P1-R2,R3]</td>\n",
-       "      <td>{'P1w': 1.986535009696659e-06, 'P1n': 0.937307...</td>\n",
+       "      <td>[C1-R2,R3-P4-[P5,R6]]</td>\n",
+       "      <td>{'C1': 1.2518230659909423e-06, 'R2': 158.85747...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>[P1,R2]-R3</td>\n",
-       "      <td>{'P1w': 1.986654419964975e-06, 'P1n': 0.937307...</td>\n",
+       "      <td>[R1-C2,P3-R4]</td>\n",
+       "      <td>{'R1': 146.56715696639486, 'C2': 1.47824291323...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>P1-[L2,R3]-[P4,R5]</td>\n",
-       "      <td>{'P1w': 0.007186637598734201, 'P1n': 5.5757649...</td>\n",
+       "      <td>C1-[R2,P3]-R4</td>\n",
+       "      <td>{'C1': 6.429085835426775e-05, 'R2': 4086839.40...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>[R1,L2]-[P3,R4]</td>\n",
-       "      <td>{'R1': 575681380.7164713, 'L2': 2.552295283120...</td>\n",
+       "      <td>[R1,P2-R3-L4-[R5,L6]]</td>\n",
+       "      <td>{'R1': 4629990.101374098, 'P2w': 1.98653501071...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>[R1,[R2,R3]-P4]</td>\n",
-       "      <td>{'R1': 3340406.185539958, 'R2': 891728744.7719...</td>\n",
+       "      <td>[P1-R2,R3]</td>\n",
+       "      <td>{'P1w': 2.0968493965977216e-08, 'P1n': 0.99999...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
+       "      <th>5</th>\n",
+       "      <td>[P1,R2]-R3</td>\n",
+       "      <td>{'P1w': 1.986654419718411e-06, 'P1n': 0.937307...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>113</th>\n",
-       "      <td>[P1-[L2,P3],[[R4-C5,L6-P7],R8]]</td>\n",
-       "      <td>{'P1w': 2.2534535379254496e-06, 'P1n': 0.87445...</td>\n",
+       "      <th>6</th>\n",
+       "      <td>[R1-P2,R3]</td>\n",
+       "      <td>{'R1': 139.15131244656453, 'P2w': 1.9865350108...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>114</th>\n",
-       "      <td>R1-[P2,[R3,P4]]</td>\n",
-       "      <td>{'R1': 142.06322312672248, 'P2w': 1.7374203222...</td>\n",
+       "      <th>7</th>\n",
+       "      <td>[P1-R2,R3]</td>\n",
+       "      <td>{'P1w': 2.3702129309162755e-08, 'P1n': 0.99999...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>115</th>\n",
-       "      <td>[R1,P2]-R3</td>\n",
-       "      <td>{'R1': 4629850.951700082, 'P2w': 1.98665442152...</td>\n",
+       "      <th>8</th>\n",
+       "      <td>[P1-R2,R3]</td>\n",
+       "      <td>{'P1w': 1.633555512329923e-08, 'P1n': 0.999999...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>R1-[R2,[R3,P4]]</td>\n",
+       "      <td>{'R1': 139.14713047789797, 'R2': 4654954.87137...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>[P1,R2]-[L3,R4]</td>\n",
+       "      <td>{'P1w': 2.302924485371552e-06, 'P1n': 0.869686...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>116</th>\n",
+       "      <th>11</th>\n",
        "      <td>[P1,R2]-R3</td>\n",
-       "      <td>{'P1w': 1.986654419725023e-06, 'P1n': 0.937307...</td>\n",
+       "      <td>{'P1w': 1.9866544198483474e-06, 'P1n': 0.93730...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>[R1,P2-R3]</td>\n",
+       "      <td>{'R1': 4629990.101402926, 'P2w': 1.98653500943...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>R1-[P2,R3]</td>\n",
+       "      <td>{'R1': 139.14713045260206, 'P2w': 1.9866544187...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>117</th>\n",
+       "      <th>14</th>\n",
+       "      <td>[R1-P2,P3]</td>\n",
+       "      <td>{'R1': 4847243.661018436, 'P2w': 3.61491996853...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
        "      <td>R1-[P2,R3]</td>\n",
-       "      <td>{'R1': 139.14713051260458, 'P2w': 1.9866544182...</td>\n",
+       "      <td>{'R1': 139.14713057315635, 'P2w': 1.9866544205...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>R1-[P2-L3,R4]</td>\n",
+       "      <td>{'R1': 139.14713044066318, 'P2w': 1.9866544191...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>[P1-R2,R3]</td>\n",
+       "      <td>{'P1w': 1.9865350111025016e-06, 'P1n': 0.93730...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>R1-[P2,R3]</td>\n",
+       "      <td>{'R1': 139.14713059613737, 'P2w': 1.9866544211...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>R1-[R2,P3]</td>\n",
+       "      <td>{'R1': 139.14713072472173, 'R2': 4629850.95198...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>P1-[P2,R3]-[R4,L5]</td>\n",
+       "      <td>{'P1w': 0.0071866376038625815, 'P1n': 2.344409...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21</th>\n",
+       "      <td>[L1-P2-R3,P4-[R5,L6]]</td>\n",
+       "      <td>{'L1': 4.999999995043704, 'P2w': 3.61491672511...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22</th>\n",
+       "      <td>P1-[P2-R3,L4-R5-L6]</td>\n",
+       "      <td>{'P1w': 3.0600477978470834e-05, 'P1n': 0.86566...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23</th>\n",
+       "      <td>[R1,P2]-R3</td>\n",
+       "      <td>{'R1': 4629850.946599953, 'P2w': 1.98665441944...</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "<p>118 rows × 2 columns</p>\n",
        "</div>"
       ],
       "text/plain": [
-       "                       circuitstring  \\\n",
-       "0                         [P1-R2,R3]   \n",
-       "1                         [P1,R2]-R3   \n",
-       "2                 P1-[L2,R3]-[P4,R5]   \n",
-       "3                    [R1,L2]-[P3,R4]   \n",
-       "4                    [R1,[R2,R3]-P4]   \n",
-       "..                               ...   \n",
-       "113  [P1-[L2,P3],[[R4-C5,L6-P7],R8]]   \n",
-       "114                  R1-[P2,[R3,P4]]   \n",
-       "115                       [R1,P2]-R3   \n",
-       "116                       [P1,R2]-R3   \n",
-       "117                       R1-[P2,R3]   \n",
-       "\n",
-       "                                            Parameters  \n",
-       "0    {'P1w': 1.986535009696659e-06, 'P1n': 0.937307...  \n",
-       "1    {'P1w': 1.986654419964975e-06, 'P1n': 0.937307...  \n",
-       "2    {'P1w': 0.007186637598734201, 'P1n': 5.5757649...  \n",
-       "3    {'R1': 575681380.7164713, 'L2': 2.552295283120...  \n",
-       "4    {'R1': 3340406.185539958, 'R2': 891728744.7719...  \n",
-       "..                                                 ...  \n",
-       "113  {'P1w': 2.2534535379254496e-06, 'P1n': 0.87445...  \n",
-       "114  {'R1': 142.06322312672248, 'P2w': 1.7374203222...  \n",
-       "115  {'R1': 4629850.951700082, 'P2w': 1.98665442152...  \n",
-       "116  {'P1w': 1.986654419725023e-06, 'P1n': 0.937307...  \n",
-       "117  {'R1': 139.14713051260458, 'P2w': 1.9866544182...  \n",
-       "\n",
-       "[118 rows x 2 columns]"
+       "            circuitstring                                         Parameters\n",
+       "0   [C1-R2,R3-P4-[P5,R6]]  {'C1': 1.2518230659909423e-06, 'R2': 158.85747...\n",
+       "1           [R1-C2,P3-R4]  {'R1': 146.56715696639486, 'C2': 1.47824291323...\n",
+       "2           C1-[R2,P3]-R4  {'C1': 6.429085835426775e-05, 'R2': 4086839.40...\n",
+       "3   [R1,P2-R3-L4-[R5,L6]]  {'R1': 4629990.101374098, 'P2w': 1.98653501071...\n",
+       "4              [P1-R2,R3]  {'P1w': 2.0968493965977216e-08, 'P1n': 0.99999...\n",
+       "5              [P1,R2]-R3  {'P1w': 1.986654419718411e-06, 'P1n': 0.937307...\n",
+       "6              [R1-P2,R3]  {'R1': 139.15131244656453, 'P2w': 1.9865350108...\n",
+       "7              [P1-R2,R3]  {'P1w': 2.3702129309162755e-08, 'P1n': 0.99999...\n",
+       "8              [P1-R2,R3]  {'P1w': 1.633555512329923e-08, 'P1n': 0.999999...\n",
+       "9         R1-[R2,[R3,P4]]  {'R1': 139.14713047789797, 'R2': 4654954.87137...\n",
+       "10        [P1,R2]-[L3,R4]  {'P1w': 2.302924485371552e-06, 'P1n': 0.869686...\n",
+       "11             [P1,R2]-R3  {'P1w': 1.9866544198483474e-06, 'P1n': 0.93730...\n",
+       "12             [R1,P2-R3]  {'R1': 4629990.101402926, 'P2w': 1.98653500943...\n",
+       "13             R1-[P2,R3]  {'R1': 139.14713045260206, 'P2w': 1.9866544187...\n",
+       "14             [R1-P2,P3]  {'R1': 4847243.661018436, 'P2w': 3.61491996853...\n",
+       "15             R1-[P2,R3]  {'R1': 139.14713057315635, 'P2w': 1.9866544205...\n",
+       "16          R1-[P2-L3,R4]  {'R1': 139.14713044066318, 'P2w': 1.9866544191...\n",
+       "17             [P1-R2,R3]  {'P1w': 1.9865350111025016e-06, 'P1n': 0.93730...\n",
+       "18             R1-[P2,R3]  {'R1': 139.14713059613737, 'P2w': 1.9866544211...\n",
+       "19             R1-[R2,P3]  {'R1': 139.14713072472173, 'R2': 4629850.95198...\n",
+       "20     P1-[P2,R3]-[R4,L5]  {'P1w': 0.0071866376038625815, 'P1n': 2.344409...\n",
+       "21  [L1-P2-R3,P4-[R5,L6]]  {'L1': 4.999999995043704, 'P2w': 3.61491672511...\n",
+       "22    P1-[P2-R3,L4-R5-L6]  {'P1w': 3.0600477978470834e-05, 'P1n': 0.86566...\n",
+       "23             [R1,P2]-R3  {'R1': 4629850.946599953, 'P2w': 1.98665441944..."
       ]
      },
-     "execution_count": 7,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "use_pregenerated_circuits = True\n",
+    "use_pregenerated_circuits = False\n",
     "\n",
     "if use_pregenerated_circuits:\n",
     "    circuits_unfiltered = ae.io.load_test_circuits()\n",
     "else:\n",
     "    kwargs = {\n",
-    "        \"iters\": 120,\n",
+    "        \"iters\": 24,\n",
     "        \"complexity\": 12,\n",
     "        \"population_size\": 100,\n",
     "        \"generations\": 30,\n",
@@ -333,7 +412,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -365,119 +444,30 @@
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>[P1,R2]-R3</td>\n",
-       "      <td>{'P1w': 1.986654419964975e-06, 'P1n': 0.937307...</td>\n",
+       "      <td>{'P1w': 1.986654419718411e-06, 'P1n': 0.937307...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>R1-P2-[P3,R4]</td>\n",
-       "      <td>{'R1': 130.21245496329337, 'P2w': 2.7265188132...</td>\n",
+       "      <td>R1-[R2,[R3,P4]]</td>\n",
+       "      <td>{'R1': 139.14713047789797, 'R2': 4654954.87137...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>P1-R2-[P3,R4]-[L5,R6]</td>\n",
-       "      <td>{'P1w': 3.060047763952672e-05, 'P1n': 0.865667...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>R1-[R2-L3,P4]</td>\n",
-       "      <td>{'R1': 139.14713070316256, 'R2': 4629850.95146...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>R1-[R2-[R3,P4],[L5,R6]-P7]</td>\n",
-       "      <td>{'R1': 141.23906880866465, 'R2': 2757765.10158...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>P1-[P2,R3]-L4-R5</td>\n",
-       "      <td>{'P1w': 3.060047791227673e-05, 'P1n': 0.865667...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>[P1,P2]-[P3,R4]-R5</td>\n",
-       "      <td>{'P1w': 1.4706292096441107e-06, 'P1n': 0.34376...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>R1-[R2,P3-R4]</td>\n",
-       "      <td>{'R1': 35.07220572671824, 'R2': 4629955.027337...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>P1-R2-[P3,R4]-R5</td>\n",
-       "      <td>{'P1w': 2.7265188153219155e-06, 'P1n': 0.86814...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>L1-[P2,R3]-[R4,L5]-P6-R7</td>\n",
-       "      <td>{'L1': 7.336357952082608e-20, 'P2w': 2.0355768...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>[P1,P2-R3]-R4</td>\n",
-       "      <td>{'P1w': 1.8172983928967454e-06, 'P1n': 0.95491...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>11</th>\n",
-       "      <td>R1-[P2-R3,[L4,R5]-P6]</td>\n",
-       "      <td>{'R1': 141.24023286281513, 'P2w': 2.2755039323...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>12</th>\n",
-       "      <td>R1-[R2,P3-L4]</td>\n",
-       "      <td>{'R1': 139.14713051318796, 'R2': 4629850.95049...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>13</th>\n",
-       "      <td>[P1,P2-[R3,L4]]-R5</td>\n",
-       "      <td>{'P1w': 9.503614832162238, 'P1n': 1.0, 'P2w': ...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>14</th>\n",
-       "      <td>R1-[P2,[R3,P4]]</td>\n",
-       "      <td>{'R1': 142.06322312672248, 'P2w': 1.7374203222...</td>\n",
+       "      <td>R1-[P2-L3,R4]</td>\n",
+       "      <td>{'R1': 139.14713044066318, 'P2w': 1.9866544191...</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "                 circuitstring  \\\n",
-       "0                   [P1,R2]-R3   \n",
-       "1                R1-P2-[P3,R4]   \n",
-       "2        P1-R2-[P3,R4]-[L5,R6]   \n",
-       "3                R1-[R2-L3,P4]   \n",
-       "4   R1-[R2-[R3,P4],[L5,R6]-P7]   \n",
-       "5             P1-[P2,R3]-L4-R5   \n",
-       "6           [P1,P2]-[P3,R4]-R5   \n",
-       "7                R1-[R2,P3-R4]   \n",
-       "8             P1-R2-[P3,R4]-R5   \n",
-       "9     L1-[P2,R3]-[R4,L5]-P6-R7   \n",
-       "10               [P1,P2-R3]-R4   \n",
-       "11       R1-[P2-R3,[L4,R5]-P6]   \n",
-       "12               R1-[R2,P3-L4]   \n",
-       "13          [P1,P2-[R3,L4]]-R5   \n",
-       "14             R1-[P2,[R3,P4]]   \n",
-       "\n",
-       "                                           Parameters  \n",
-       "0   {'P1w': 1.986654419964975e-06, 'P1n': 0.937307...  \n",
-       "1   {'R1': 130.21245496329337, 'P2w': 2.7265188132...  \n",
-       "2   {'P1w': 3.060047763952672e-05, 'P1n': 0.865667...  \n",
-       "3   {'R1': 139.14713070316256, 'R2': 4629850.95146...  \n",
-       "4   {'R1': 141.23906880866465, 'R2': 2757765.10158...  \n",
-       "5   {'P1w': 3.060047791227673e-05, 'P1n': 0.865667...  \n",
-       "6   {'P1w': 1.4706292096441107e-06, 'P1n': 0.34376...  \n",
-       "7   {'R1': 35.07220572671824, 'R2': 4629955.027337...  \n",
-       "8   {'P1w': 2.7265188153219155e-06, 'P1n': 0.86814...  \n",
-       "9   {'L1': 7.336357952082608e-20, 'P2w': 2.0355768...  \n",
-       "10  {'P1w': 1.8172983928967454e-06, 'P1n': 0.95491...  \n",
-       "11  {'R1': 141.24023286281513, 'P2w': 2.2755039323...  \n",
-       "12  {'R1': 139.14713051318796, 'R2': 4629850.95049...  \n",
-       "13  {'P1w': 9.503614832162238, 'P1n': 1.0, 'P2w': ...  \n",
-       "14  {'R1': 142.06322312672248, 'P2w': 1.7374203222...  "
+       "     circuitstring                                         Parameters\n",
+       "0       [P1,R2]-R3  {'P1w': 1.986654419718411e-06, 'P1n': 0.937307...\n",
+       "1  R1-[R2,[R3,P4]]  {'R1': 139.14713047789797, 'R2': 4654954.87137...\n",
+       "2    R1-[P2-L3,R4]  {'R1': 139.14713044066318, 'P2w': 1.9866544191..."
       ]
      },
-     "execution_count": 8,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -503,9 +493,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " "
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "aadc9d9ef12943ff9c35fca9541f9555",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "mcmc_results = ae.core.perform_bayesian_inference(circuits, Z, freq)\n",
     "mcmcs, status = zip(*mcmc_results)"
@@ -524,7 +543,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -534,12 +553,12 @@
        "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
        "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
        "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P1n │ 6.27e-01 │ 1.37e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
-       "│        P1w │ 1.44e-06 │ 4.53e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
-       "│         R2 │ 7.39e+06 │ 2.54e+04 │ 7.39e+06 │ 7.35e+06 │ 7.44e+06 │\n",
-       "│<span style=\"background-color: #808000\">         R3 </span>│<span style=\"background-color: #808000\"> 2.32e+01 </span>│<span style=\"background-color: #808000\"> 3.11e+01 </span>│<span style=\"background-color: #808000\"> 1.25e+01 </span>│<span style=\"background-color: #808000\"> 7.82e-01 </span>│<span style=\"background-color: #808000\"> 8.00e+01 </span>│\n",
-       "│ sigma_imag │ 1.11e+04 │ 6.79e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
-       "│ sigma_real │ 1.11e+04 │ 7.05e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
+       "│        P1n │ 6.27e-01 │ 1.34e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
+       "│        P1w │ 1.44e-06 │ 4.37e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
+       "│         R2 │ 7.39e+06 │ 2.59e+04 │ 7.39e+06 │ 7.35e+06 │ 7.44e+06 │\n",
+       "│<span style=\"background-color: #808000\">         R3 </span>│<span style=\"background-color: #808000\"> 2.43e+01 </span>│<span style=\"background-color: #808000\"> 3.05e+01 </span>│<span style=\"background-color: #808000\"> 1.35e+01 </span>│<span style=\"background-color: #808000\"> 7.35e-01 </span>│<span style=\"background-color: #808000\"> 8.58e+01 </span>│\n",
+       "│ sigma_imag │ 1.11e+04 │ 7.17e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
+       "│ sigma_real │ 1.11e+04 │ 7.04e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
        "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
        "</pre>\n"
       ],
@@ -548,49 +567,12 @@
        "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
        "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
        "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P1n │ 6.27e-01 │ 1.37e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
-       "│        P1w │ 1.44e-06 │ 4.53e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
-       "│         R2 │ 7.39e+06 │ 2.54e+04 │ 7.39e+06 │ 7.35e+06 │ 7.44e+06 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R3\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.32e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.11e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.25e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m7.82e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.00e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│ sigma_imag │ 1.11e+04 │ 6.79e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
-       "│ sigma_real │ 1.11e+04 │ 7.05e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                  R1-P2-[P3,R4], 0/1000 divergences                  </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P2n │ 3.51e-01 │ 5.60e-04 │ 3.51e-01 │ 3.50e-01 │ 3.52e-01 │\n",
-       "│        P2w │ 1.00e-06 │ 2.48e-09 │ 1.00e-06 │ 1.00e-06 │ 1.01e-06 │\n",
-       "│        P3n │ 5.03e-01 │ 2.83e-01 │ 5.04e-01 │ 6.26e-02 │ 9.43e-01 │\n",
-       "│<span style=\"background-color: #808000\">        P3w </span>│<span style=\"background-color: #808000\"> 1.03e+10 </span>│<span style=\"background-color: #808000\"> 5.21e+10 </span>│<span style=\"background-color: #808000\"> 8.91e+08 </span>│<span style=\"background-color: #808000\"> 1.90e+07 </span>│<span style=\"background-color: #808000\"> 3.77e+10 </span>│\n",
-       "│<span style=\"background-color: #808000\">         R1 </span>│<span style=\"background-color: #808000\"> 2.37e+01 </span>│<span style=\"background-color: #808000\"> 2.95e+01 </span>│<span style=\"background-color: #808000\"> 1.27e+01 </span>│<span style=\"background-color: #808000\"> 8.51e-01 </span>│<span style=\"background-color: #808000\"> 8.51e+01 </span>│\n",
-       "│<span style=\"background-color: #808000\">         R4 </span>│<span style=\"background-color: #808000\"> 1.68e+09 </span>│<span style=\"background-color: #808000\"> 1.04e+10 </span>│<span style=\"background-color: #808000\"> 1.08e+08 </span>│<span style=\"background-color: #808000\"> 1.62e+06 </span>│<span style=\"background-color: #808000\"> 6.13e+09 </span>│\n",
-       "│ sigma_imag │ 1.58e+04 │ 7.97e+01 │ 1.58e+04 │ 1.56e+04 │ 1.59e+04 │\n",
-       "│ sigma_real │ 1.95e+04 │ 7.92e+01 │ 1.95e+04 │ 1.94e+04 │ 1.97e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m                  R1-P2-[P3,R4], 0/1000 divergences                  \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P2n │ 3.51e-01 │ 5.60e-04 │ 3.51e-01 │ 3.50e-01 │ 3.52e-01 │\n",
-       "│        P2w │ 1.00e-06 │ 2.48e-09 │ 1.00e-06 │ 1.00e-06 │ 1.01e-06 │\n",
-       "│        P3n │ 5.03e-01 │ 2.83e-01 │ 5.04e-01 │ 6.26e-02 │ 9.43e-01 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m       P3w\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.03e+10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.21e+10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.91e+08\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.90e+07\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.77e+10\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R1\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.37e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.95e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.27e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.51e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.51e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R4\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.68e+09\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.04e+10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.08e+08\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.62e+06\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m6.13e+09\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│ sigma_imag │ 1.58e+04 │ 7.97e+01 │ 1.58e+04 │ 1.56e+04 │ 1.59e+04 │\n",
-       "│ sigma_real │ 1.95e+04 │ 7.92e+01 │ 1.95e+04 │ 1.94e+04 │ 1.97e+04 │\n",
+       "│        P1n │ 6.27e-01 │ 1.34e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
+       "│        P1w │ 1.44e-06 │ 4.37e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
+       "│         R2 │ 7.39e+06 │ 2.59e+04 │ 7.39e+06 │ 7.35e+06 │ 7.44e+06 │\n",
+       "│\u001b[43m \u001b[0m\u001b[43m        R3\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.43e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.05e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.35e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m7.35e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.58e+01\u001b[0m\u001b[43m \u001b[0m│\n",
+       "│ sigma_imag │ 1.11e+04 │ 7.17e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
+       "│ sigma_real │ 1.11e+04 │ 7.04e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
        "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
       ]
      },
@@ -600,32 +582,32 @@
     {
      "data": {
       "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                  R1-[R2-L3,P4], 0/1000 divergences                  </span>\n",
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                R1-[R2,[R3,P4]], 18/1000 divergences                 </span>\n",
        "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
        "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
        "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│<span style=\"background-color: #808000\">         L3 </span>│<span style=\"background-color: #808000\"> 5.31e-08 </span>│<span style=\"background-color: #808000\"> 3.38e-07 </span>│<span style=\"background-color: #808000\"> 4.74e-09 </span>│<span style=\"background-color: #808000\"> 1.01e-10 </span>│<span style=\"background-color: #808000\"> 1.71e-07 </span>│\n",
-       "│        P4n │ 6.27e-01 │ 1.43e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
-       "│        P4w │ 1.44e-06 │ 4.71e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
-       "│<span style=\"background-color: #808000\">         R1 </span>│<span style=\"background-color: #808000\"> 2.33e+01 </span>│<span style=\"background-color: #808000\"> 2.87e+01 </span>│<span style=\"background-color: #808000\"> 1.24e+01 </span>│<span style=\"background-color: #808000\"> 1.02e+00 </span>│<span style=\"background-color: #808000\"> 7.98e+01 </span>│\n",
-       "│         R2 │ 7.39e+06 │ 2.70e+04 │ 7.39e+06 │ 7.35e+06 │ 7.44e+06 │\n",
-       "│ sigma_imag │ 1.11e+04 │ 7.28e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
-       "│ sigma_real │ 1.11e+04 │ 7.03e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
+       "│        P4n │ 6.27e-01 │ 1.39e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
+       "│        P4w │ 1.44e-06 │ 4.57e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
+       "│<span style=\"background-color: #808000\">         R1 </span>│<span style=\"background-color: #808000\"> 3.16e+01 </span>│<span style=\"background-color: #808000\"> 4.20e+01 </span>│<span style=\"background-color: #808000\"> 1.58e+01 </span>│<span style=\"background-color: #808000\"> 8.14e-01 </span>│<span style=\"background-color: #808000\"> 1.40e+02 </span>│\n",
+       "│         R2 │ 7.69e+06 │ 3.79e+05 │ 7.51e+06 │ 7.38e+06 │ 8.61e+06 │\n",
+       "│<span style=\"background-color: #808000\">         R3 </span>│<span style=\"background-color: #808000\"> 1.45e+10 </span>│<span style=\"background-color: #808000\"> 1.37e+11 </span>│<span style=\"background-color: #808000\"> 5.16e+08 </span>│<span style=\"background-color: #808000\"> 5.11e+07 </span>│<span style=\"background-color: #808000\"> 2.62e+10 </span>│\n",
+       "│ sigma_imag │ 1.11e+04 │ 6.91e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
+       "│ sigma_real │ 1.11e+04 │ 6.82e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
        "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
        "</pre>\n"
       ],
       "text/plain": [
-       "\u001b[3m                  R1-[R2-L3,P4], 0/1000 divergences                  \u001b[0m\n",
+       "\u001b[3m                R1-[R2,[R3,P4]], 18/1000 divergences                 \u001b[0m\n",
        "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
        "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
        "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        L3\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.31e-08\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.38e-07\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.74e-09\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.01e-10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.71e-07\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│        P4n │ 6.27e-01 │ 1.43e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
-       "│        P4w │ 1.44e-06 │ 4.71e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R1\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.33e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.87e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.24e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.02e+00\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m7.98e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│         R2 │ 7.39e+06 │ 2.70e+04 │ 7.39e+06 │ 7.35e+06 │ 7.44e+06 │\n",
-       "│ sigma_imag │ 1.11e+04 │ 7.28e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
-       "│ sigma_real │ 1.11e+04 │ 7.03e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
+       "│        P4n │ 6.27e-01 │ 1.39e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
+       "│        P4w │ 1.44e-06 │ 4.57e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
+       "│\u001b[43m \u001b[0m\u001b[43m        R1\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.16e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.20e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.58e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.14e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.40e+02\u001b[0m\u001b[43m \u001b[0m│\n",
+       "│         R2 │ 7.69e+06 │ 3.79e+05 │ 7.51e+06 │ 7.38e+06 │ 8.61e+06 │\n",
+       "│\u001b[43m \u001b[0m\u001b[43m        R3\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.45e+10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.37e+11\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.16e+08\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.11e+07\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.62e+10\u001b[0m\u001b[43m \u001b[0m│\n",
+       "│ sigma_imag │ 1.11e+04 │ 6.91e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
+       "│ sigma_real │ 1.11e+04 │ 6.82e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
        "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
       ]
      },
@@ -635,342 +617,32 @@
     {
      "data": {
       "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">           R1-[R2-[R3,P4],[L5,R6]-P7], 0/1000 divergences            </span>\n",
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                  R1-[P2-L3,R4], 0/1000 divergences                  </span>\n",
        "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
        "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
        "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│         L5 │ 6.19e-17 │ 0.00e+00 │ 6.19e-17 │ 6.19e-17 │ 6.19e-17 │\n",
-       "│        P4n │ 3.33e-01 │ 0.00e+00 │ 3.33e-01 │ 3.33e-01 │ 3.33e-01 │\n",
-       "│        P4w │ 1.48e-06 │ 0.00e+00 │ 1.48e-06 │ 1.48e-06 │ 1.48e-06 │\n",
-       "│        P7n │ 8.94e-01 │ 5.96e-08 │ 8.94e-01 │ 8.94e-01 │ 8.94e-01 │\n",
-       "│        P7w │ 1.60e-06 │ 0.00e+00 │ 1.60e-06 │ 1.60e-06 │ 1.60e-06 │\n",
-       "│         R1 │ 6.13e+01 │ 0.00e+00 │ 6.13e+01 │ 6.13e+01 │ 6.13e+01 │\n",
-       "│         R2 │ 2.50e+06 │ 0.00e+00 │ 2.50e+06 │ 2.50e+06 │ 2.50e+06 │\n",
-       "│         R3 │ 4.16e+09 │ 0.00e+00 │ 4.16e+09 │ 4.16e+09 │ 4.16e+09 │\n",
-       "│         R6 │ 1.68e+09 │ 1.28e+02 │ 1.68e+09 │ 1.68e+09 │ 1.68e+09 │\n",
-       "│ sigma_imag │ 8.81e+00 │ 9.54e-07 │ 8.81e+00 │ 8.81e+00 │ 8.81e+00 │\n",
-       "│ sigma_real │ 1.07e+01 │ 9.54e-07 │ 1.07e+01 │ 1.07e+01 │ 1.07e+01 │\n",
+       "│<span style=\"background-color: #808000\">         L3 </span>│<span style=\"background-color: #808000\"> 5.89e-20 </span>│<span style=\"background-color: #808000\"> 2.79e-19 </span>│<span style=\"background-color: #808000\"> 4.50e-21 </span>│<span style=\"background-color: #808000\"> 6.35e-23 </span>│<span style=\"background-color: #808000\"> 2.02e-19 </span>│\n",
+       "│        P2n │ 6.27e-01 │ 1.40e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
+       "│        P2w │ 1.44e-06 │ 4.50e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
+       "│<span style=\"background-color: #808000\">         R1 </span>│<span style=\"background-color: #808000\"> 2.36e+01 </span>│<span style=\"background-color: #808000\"> 2.96e+01 </span>│<span style=\"background-color: #808000\"> 1.35e+01 </span>│<span style=\"background-color: #808000\"> 1.18e+00 </span>│<span style=\"background-color: #808000\"> 7.83e+01 </span>│\n",
+       "│         R4 │ 7.39e+06 │ 2.64e+04 │ 7.39e+06 │ 7.35e+06 │ 7.43e+06 │\n",
+       "│ sigma_imag │ 1.11e+04 │ 7.03e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
+       "│ sigma_real │ 1.11e+04 │ 7.55e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
        "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
        "</pre>\n"
       ],
       "text/plain": [
-       "\u001b[3m           R1-[R2-[R3,P4],[L5,R6]-P7], 0/1000 divergences            \u001b[0m\n",
+       "\u001b[3m                  R1-[P2-L3,R4], 0/1000 divergences                  \u001b[0m\n",
        "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
        "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
        "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│         L5 │ 6.19e-17 │ 0.00e+00 │ 6.19e-17 │ 6.19e-17 │ 6.19e-17 │\n",
-       "│        P4n │ 3.33e-01 │ 0.00e+00 │ 3.33e-01 │ 3.33e-01 │ 3.33e-01 │\n",
-       "│        P4w │ 1.48e-06 │ 0.00e+00 │ 1.48e-06 │ 1.48e-06 │ 1.48e-06 │\n",
-       "│        P7n │ 8.94e-01 │ 5.96e-08 │ 8.94e-01 │ 8.94e-01 │ 8.94e-01 │\n",
-       "│        P7w │ 1.60e-06 │ 0.00e+00 │ 1.60e-06 │ 1.60e-06 │ 1.60e-06 │\n",
-       "│         R1 │ 6.13e+01 │ 0.00e+00 │ 6.13e+01 │ 6.13e+01 │ 6.13e+01 │\n",
-       "│         R2 │ 2.50e+06 │ 0.00e+00 │ 2.50e+06 │ 2.50e+06 │ 2.50e+06 │\n",
-       "│         R3 │ 4.16e+09 │ 0.00e+00 │ 4.16e+09 │ 4.16e+09 │ 4.16e+09 │\n",
-       "│         R6 │ 1.68e+09 │ 1.28e+02 │ 1.68e+09 │ 1.68e+09 │ 1.68e+09 │\n",
-       "│ sigma_imag │ 8.81e+00 │ 9.54e-07 │ 8.81e+00 │ 8.81e+00 │ 8.81e+00 │\n",
-       "│ sigma_real │ 1.07e+01 │ 9.54e-07 │ 1.07e+01 │ 1.07e+01 │ 1.07e+01 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                P1-[P2,R3]-L4-R5, 0/1000 divergences                 </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│<span style=\"background-color: #808000\">         L4 </span>│<span style=\"background-color: #808000\"> 1.16e-19 </span>│<span style=\"background-color: #808000\"> 8.32e-19 </span>│<span style=\"background-color: #808000\"> 6.95e-21 </span>│<span style=\"background-color: #808000\"> 1.70e-22 </span>│<span style=\"background-color: #808000\"> 3.93e-19 </span>│\n",
-       "│        P1n │ 5.55e-01 │ 1.80e-03 │ 5.55e-01 │ 5.52e-01 │ 5.58e-01 │\n",
-       "│        P1w │ 5.93e-06 │ 7.40e-08 │ 5.93e-06 │ 5.82e-06 │ 6.07e-06 │\n",
-       "│        P2n │ 8.94e-01 │ 1.45e-03 │ 8.94e-01 │ 8.92e-01 │ 8.96e-01 │\n",
-       "│        P2w │ 2.41e-06 │ 1.30e-08 │ 2.41e-06 │ 2.39e-06 │ 2.43e-06 │\n",
-       "│         R3 │ 3.21e+06 │ 1.27e+04 │ 3.21e+06 │ 3.19e+06 │ 3.23e+06 │\n",
-       "│<span style=\"background-color: #808000\">         R5 </span>│<span style=\"background-color: #808000\"> 1.50e+01 </span>│<span style=\"background-color: #808000\"> 1.98e+01 </span>│<span style=\"background-color: #808000\"> 8.45e+00 </span>│<span style=\"background-color: #808000\"> 5.96e-01 </span>│<span style=\"background-color: #808000\"> 5.15e+01 </span>│\n",
-       "│ sigma_imag │ 3.50e+03 │ 3.58e+01 │ 3.50e+03 │ 3.44e+03 │ 3.56e+03 │\n",
-       "│ sigma_real │ 5.27e+03 │ 4.32e+01 │ 5.27e+03 │ 5.19e+03 │ 5.34e+03 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m                P1-[P2,R3]-L4-R5, 0/1000 divergences                 \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        L4\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.16e-19\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.32e-19\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m6.95e-21\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.70e-22\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.93e-19\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│        P1n │ 5.55e-01 │ 1.80e-03 │ 5.55e-01 │ 5.52e-01 │ 5.58e-01 │\n",
-       "│        P1w │ 5.93e-06 │ 7.40e-08 │ 5.93e-06 │ 5.82e-06 │ 6.07e-06 │\n",
-       "│        P2n │ 8.94e-01 │ 1.45e-03 │ 8.94e-01 │ 8.92e-01 │ 8.96e-01 │\n",
-       "│        P2w │ 2.41e-06 │ 1.30e-08 │ 2.41e-06 │ 2.39e-06 │ 2.43e-06 │\n",
-       "│         R3 │ 3.21e+06 │ 1.27e+04 │ 3.21e+06 │ 3.19e+06 │ 3.23e+06 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R5\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.50e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.98e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.45e+00\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.96e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.15e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│ sigma_imag │ 3.50e+03 │ 3.58e+01 │ 3.50e+03 │ 3.44e+03 │ 3.56e+03 │\n",
-       "│ sigma_real │ 5.27e+03 │ 4.32e+01 │ 5.27e+03 │ 5.19e+03 │ 5.34e+03 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">              [P1,P2]-[P3,R4]-R5, 140/1000 divergences               </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P1n │ 5.10e-01 │ 5.96e-08 │ 5.10e-01 │ 5.10e-01 │ 5.10e-01 │\n",
-       "│        P1w │ 1.65e-06 │ 1.14e-13 │ 1.65e-06 │ 1.65e-06 │ 1.65e-06 │\n",
-       "│        P2n │ 6.56e-01 │ 5.96e-08 │ 6.56e-01 │ 6.56e-01 │ 6.56e-01 │\n",
-       "│        P2w │ 8.11e-06 │ 0.00e+00 │ 8.11e-06 │ 8.11e-06 │ 8.11e-06 │\n",
-       "│        P3n │ 8.16e-01 │ 5.96e-08 │ 8.16e-01 │ 8.16e-01 │ 8.16e-01 │\n",
-       "│        P3w │ 1.90e-06 │ 1.14e-13 │ 1.90e-06 │ 1.90e-06 │ 1.90e-06 │\n",
-       "│         R4 │ 3.75e+06 │ 0.00e+00 │ 3.75e+06 │ 3.75e+06 │ 3.75e+06 │\n",
-       "│         R5 │ 1.89e+02 │ 0.00e+00 │ 1.89e+02 │ 1.89e+02 │ 1.89e+02 │\n",
-       "│ sigma_imag │ 3.72e+00 │ 0.00e+00 │ 3.72e+00 │ 3.72e+00 │ 3.72e+00 │\n",
-       "│ sigma_real │ 6.43e+00 │ 4.77e-07 │ 6.43e+00 │ 6.43e+00 │ 6.43e+00 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m              [P1,P2]-[P3,R4]-R5, 140/1000 divergences               \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P1n │ 5.10e-01 │ 5.96e-08 │ 5.10e-01 │ 5.10e-01 │ 5.10e-01 │\n",
-       "│        P1w │ 1.65e-06 │ 1.14e-13 │ 1.65e-06 │ 1.65e-06 │ 1.65e-06 │\n",
-       "│        P2n │ 6.56e-01 │ 5.96e-08 │ 6.56e-01 │ 6.56e-01 │ 6.56e-01 │\n",
-       "│        P2w │ 8.11e-06 │ 0.00e+00 │ 8.11e-06 │ 8.11e-06 │ 8.11e-06 │\n",
-       "│        P3n │ 8.16e-01 │ 5.96e-08 │ 8.16e-01 │ 8.16e-01 │ 8.16e-01 │\n",
-       "│        P3w │ 1.90e-06 │ 1.14e-13 │ 1.90e-06 │ 1.90e-06 │ 1.90e-06 │\n",
-       "│         R4 │ 3.75e+06 │ 0.00e+00 │ 3.75e+06 │ 3.75e+06 │ 3.75e+06 │\n",
-       "│         R5 │ 1.89e+02 │ 0.00e+00 │ 1.89e+02 │ 1.89e+02 │ 1.89e+02 │\n",
-       "│ sigma_imag │ 3.72e+00 │ 0.00e+00 │ 3.72e+00 │ 3.72e+00 │ 3.72e+00 │\n",
-       "│ sigma_real │ 6.43e+00 │ 4.77e-07 │ 6.43e+00 │ 6.43e+00 │ 6.43e+00 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                  R1-[R2,P3-R4], 0/1000 divergences                  </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P3n │ 6.27e-01 │ 1.43e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
-       "│        P3w │ 1.44e-06 │ 4.64e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
-       "│<span style=\"background-color: #808000\">         R1 </span>│<span style=\"background-color: #808000\"> 1.54e+01 </span>│<span style=\"background-color: #808000\"> 2.24e+01 </span>│<span style=\"background-color: #808000\"> 6.66e+00 </span>│<span style=\"background-color: #808000\"> 3.69e-01 </span>│<span style=\"background-color: #808000\"> 5.81e+01 </span>│\n",
-       "│         R2 │ 7.40e+06 │ 2.67e+04 │ 7.40e+06 │ 7.35e+06 │ 7.44e+06 │\n",
-       "│<span style=\"background-color: #808000\">         R4 </span>│<span style=\"background-color: #808000\"> 2.24e+01 </span>│<span style=\"background-color: #808000\"> 2.88e+01 </span>│<span style=\"background-color: #808000\"> 1.22e+01 </span>│<span style=\"background-color: #808000\"> 6.75e-01 </span>│<span style=\"background-color: #808000\"> 8.39e+01 </span>│\n",
-       "│ sigma_imag │ 1.11e+04 │ 7.24e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
-       "│ sigma_real │ 1.11e+04 │ 7.40e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m                  R1-[R2,P3-R4], 0/1000 divergences                  \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P3n │ 6.27e-01 │ 1.43e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
-       "│        P3w │ 1.44e-06 │ 4.64e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R1\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.54e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.24e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m6.66e+00\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.69e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.81e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│         R2 │ 7.40e+06 │ 2.67e+04 │ 7.40e+06 │ 7.35e+06 │ 7.44e+06 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R4\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.24e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.88e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.22e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m6.75e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.39e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│ sigma_imag │ 1.11e+04 │ 7.24e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
-       "│ sigma_real │ 1.11e+04 │ 7.40e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                P1-R2-[P3,R4]-R5, 0/1000 divergences                 </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P1n │ 3.51e-01 │ 5.90e-04 │ 3.51e-01 │ 3.50e-01 │ 3.52e-01 │\n",
-       "│        P1w │ 1.00e-06 │ 2.70e-09 │ 1.00e-06 │ 1.00e-06 │ 1.01e-06 │\n",
-       "│        P3n │ 4.96e-01 │ 2.91e-01 │ 4.88e-01 │ 4.89e-02 │ 9.47e-01 │\n",
-       "│<span style=\"background-color: #808000\">        P3w </span>│<span style=\"background-color: #808000\"> 2.99e+09 </span>│<span style=\"background-color: #808000\"> 8.91e+09 </span>│<span style=\"background-color: #808000\"> 4.66e+08 </span>│<span style=\"background-color: #808000\"> 1.44e+07 </span>│<span style=\"background-color: #808000\"> 1.26e+10 </span>│\n",
-       "│<span style=\"background-color: #808000\">         R2 </span>│<span style=\"background-color: #808000\"> 1.90e+01 </span>│<span style=\"background-color: #808000\"> 2.56e+01 </span>│<span style=\"background-color: #808000\"> 9.58e+00 </span>│<span style=\"background-color: #808000\"> 5.56e-01 </span>│<span style=\"background-color: #808000\"> 7.13e+01 </span>│\n",
-       "│<span style=\"background-color: #808000\">         R4 </span>│<span style=\"background-color: #808000\"> 3.30e+09 </span>│<span style=\"background-color: #808000\"> 1.11e+10 </span>│<span style=\"background-color: #808000\"> 4.08e+08 </span>│<span style=\"background-color: #808000\"> 1.11e+07 </span>│<span style=\"background-color: #808000\"> 1.36e+10 </span>│\n",
-       "│<span style=\"background-color: #808000\">         R5 </span>│<span style=\"background-color: #808000\"> 1.70e+01 </span>│<span style=\"background-color: #808000\"> 2.33e+01 </span>│<span style=\"background-color: #808000\"> 8.87e+00 </span>│<span style=\"background-color: #808000\"> 6.06e-01 </span>│<span style=\"background-color: #808000\"> 5.88e+01 </span>│\n",
-       "│ sigma_imag │ 1.58e+04 │ 8.10e+01 │ 1.58e+04 │ 1.56e+04 │ 1.59e+04 │\n",
-       "│ sigma_real │ 1.95e+04 │ 9.03e+01 │ 1.95e+04 │ 1.94e+04 │ 1.97e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m                P1-R2-[P3,R4]-R5, 0/1000 divergences                 \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P1n │ 3.51e-01 │ 5.90e-04 │ 3.51e-01 │ 3.50e-01 │ 3.52e-01 │\n",
-       "│        P1w │ 1.00e-06 │ 2.70e-09 │ 1.00e-06 │ 1.00e-06 │ 1.01e-06 │\n",
-       "│        P3n │ 4.96e-01 │ 2.91e-01 │ 4.88e-01 │ 4.89e-02 │ 9.47e-01 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m       P3w\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.99e+09\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.91e+09\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.66e+08\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.44e+07\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.26e+10\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R2\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.90e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.56e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m9.58e+00\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.56e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m7.13e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R4\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.30e+09\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.11e+10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.08e+08\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.11e+07\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.36e+10\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R5\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.70e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.33e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.87e+00\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m6.06e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.88e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│ sigma_imag │ 1.58e+04 │ 8.10e+01 │ 1.58e+04 │ 1.56e+04 │ 1.59e+04 │\n",
-       "│ sigma_real │ 1.95e+04 │ 9.03e+01 │ 1.95e+04 │ 1.94e+04 │ 1.97e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                 [P1,P2-R3]-R4, 243/1000 divergences                 </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P1n │ 9.01e-01 │ 5.96e-08 │ 9.01e-01 │ 9.01e-01 │ 9.01e-01 │\n",
-       "│        P1w │ 1.74e-06 │ 0.00e+00 │ 1.74e-06 │ 1.74e-06 │ 1.74e-06 │\n",
-       "│        P2n │ 4.93e-01 │ 2.98e-08 │ 4.93e-01 │ 4.93e-01 │ 4.93e-01 │\n",
-       "│        P2w │ 4.26e-06 │ 0.00e+00 │ 4.26e-06 │ 4.26e-06 │ 4.26e-06 │\n",
-       "│         R3 │ 3.48e+06 │ 2.50e-01 │ 3.48e+06 │ 3.48e+06 │ 3.48e+06 │\n",
-       "│         R4 │ 1.20e+02 │ 0.00e+00 │ 1.20e+02 │ 1.20e+02 │ 1.20e+02 │\n",
-       "│ sigma_imag │ 1.04e+00 │ 3.45e-07 │ 1.04e+00 │ 1.04e+00 │ 1.04e+00 │\n",
-       "│ sigma_real │ 1.80e+00 │ 0.00e+00 │ 1.80e+00 │ 1.80e+00 │ 1.80e+00 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m                 [P1,P2-R3]-R4, 243/1000 divergences                 \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P1n │ 9.01e-01 │ 5.96e-08 │ 9.01e-01 │ 9.01e-01 │ 9.01e-01 │\n",
-       "│        P1w │ 1.74e-06 │ 0.00e+00 │ 1.74e-06 │ 1.74e-06 │ 1.74e-06 │\n",
-       "│        P2n │ 4.93e-01 │ 2.98e-08 │ 4.93e-01 │ 4.93e-01 │ 4.93e-01 │\n",
-       "│        P2w │ 4.26e-06 │ 0.00e+00 │ 4.26e-06 │ 4.26e-06 │ 4.26e-06 │\n",
-       "│         R3 │ 3.48e+06 │ 2.50e-01 │ 3.48e+06 │ 3.48e+06 │ 3.48e+06 │\n",
-       "│         R4 │ 1.20e+02 │ 0.00e+00 │ 1.20e+02 │ 1.20e+02 │ 1.20e+02 │\n",
-       "│ sigma_imag │ 1.04e+00 │ 3.45e-07 │ 1.04e+00 │ 1.04e+00 │ 1.04e+00 │\n",
-       "│ sigma_real │ 1.80e+00 │ 0.00e+00 │ 1.80e+00 │ 1.80e+00 │ 1.80e+00 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                  R1-[R2,P3-L4], 0/1000 divergences                  </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│<span style=\"background-color: #808000\">         L4 </span>│<span style=\"background-color: #808000\"> 4.47e-20 </span>│<span style=\"background-color: #808000\"> 1.82e-19 </span>│<span style=\"background-color: #808000\"> 3.70e-21 </span>│<span style=\"background-color: #808000\"> 1.42e-22 </span>│<span style=\"background-color: #808000\"> 1.76e-19 </span>│\n",
-       "│        P3n │ 6.27e-01 │ 1.35e-03 │ 6.27e-01 │ 6.25e-01 │ 6.30e-01 │\n",
-       "│        P3w │ 1.44e-06 │ 4.51e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
-       "│<span style=\"background-color: #808000\">         R1 </span>│<span style=\"background-color: #808000\"> 2.22e+01 </span>│<span style=\"background-color: #808000\"> 2.96e+01 </span>│<span style=\"background-color: #808000\"> 1.16e+01 </span>│<span style=\"background-color: #808000\"> 8.09e-01 </span>│<span style=\"background-color: #808000\"> 7.89e+01 </span>│\n",
-       "│         R2 │ 7.39e+06 │ 2.50e+04 │ 7.39e+06 │ 7.35e+06 │ 7.44e+06 │\n",
-       "│ sigma_imag │ 1.11e+04 │ 7.15e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
-       "│ sigma_real │ 1.11e+04 │ 6.92e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m                  R1-[R2,P3-L4], 0/1000 divergences                  \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        L4\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.47e-20\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.82e-19\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.70e-21\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.42e-22\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.76e-19\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│        P3n │ 6.27e-01 │ 1.35e-03 │ 6.27e-01 │ 6.25e-01 │ 6.30e-01 │\n",
-       "│        P3w │ 1.44e-06 │ 4.51e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R1\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.22e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.96e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.16e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.09e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m7.89e+01\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│         R2 │ 7.39e+06 │ 2.50e+04 │ 7.39e+06 │ 7.35e+06 │ 7.44e+06 │\n",
-       "│ sigma_imag │ 1.11e+04 │ 7.15e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
-       "│ sigma_real │ 1.11e+04 │ 6.92e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">               [P1,P2-[R3,L4]]-R5, 0/1000 divergences                </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│<span style=\"background-color: #808000\">         L4 </span>│<span style=\"background-color: #808000\"> 9.64e+01 </span>│<span style=\"background-color: #808000\"> 1.01e+03 </span>│<span style=\"background-color: #808000\"> 4.93e+00 </span>│<span style=\"background-color: #808000\"> 1.21e-01 </span>│<span style=\"background-color: #808000\"> 2.11e+02 </span>│\n",
-       "│        P1n │ 5.08e-01 │ 2.86e-01 │ 5.08e-01 │ 5.74e-02 │ 9.51e-01 │\n",
-       "│<span style=\"background-color: #808000\">        P1w </span>│<span style=\"background-color: #808000\"> 2.68e+02 </span>│<span style=\"background-color: #808000\"> 2.76e+03 </span>│<span style=\"background-color: #808000\"> 9.17e+00 </span>│<span style=\"background-color: #808000\"> 2.75e-01 </span>│<span style=\"background-color: #808000\"> 4.20e+02 </span>│\n",
-       "│        P2n │ 5.09e-01 │ 2.87e-01 │ 5.10e-01 │ 5.77e-02 │ 9.51e-01 │\n",
-       "│<span style=\"background-color: #808000\">        P2w </span>│<span style=\"background-color: #808000\"> 1.37e+10 </span>│<span style=\"background-color: #808000\"> 8.02e+10 </span>│<span style=\"background-color: #808000\"> 8.81e+08 </span>│<span style=\"background-color: #808000\"> 1.85e+07 </span>│<span style=\"background-color: #808000\"> 4.48e+10 </span>│\n",
-       "│<span style=\"background-color: #808000\">         R3 </span>│<span style=\"background-color: #808000\"> 1.31e+10 </span>│<span style=\"background-color: #808000\"> 1.39e+11 </span>│<span style=\"background-color: #808000\"> 1.00e+09 </span>│<span style=\"background-color: #808000\"> 3.55e+07 </span>│<span style=\"background-color: #808000\"> 2.64e+10 </span>│\n",
-       "│         R5 │ 7.31e+05 │ 6.44e+03 │ 7.31e+05 │ 7.20e+05 │ 7.41e+05 │\n",
-       "│ sigma_imag │ 3.68e+04 │ 1.06e+02 │ 3.68e+04 │ 3.66e+04 │ 3.70e+04 │\n",
-       "│ sigma_real │ 4.95e+04 │ 1.24e+02 │ 4.95e+04 │ 4.93e+04 │ 4.97e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m               [P1,P2-[R3,L4]]-R5, 0/1000 divergences                \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        L4\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m9.64e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.01e+03\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.93e+00\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.21e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.11e+02\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│        P1n │ 5.08e-01 │ 2.86e-01 │ 5.08e-01 │ 5.74e-02 │ 9.51e-01 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m       P1w\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.68e+02\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.76e+03\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m9.17e+00\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.75e-01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.20e+02\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│        P2n │ 5.09e-01 │ 2.87e-01 │ 5.10e-01 │ 5.77e-02 │ 9.51e-01 │\n",
-       "│\u001b[43m \u001b[0m\u001b[43m       P2w\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.37e+10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.02e+10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m8.81e+08\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.85e+07\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.48e+10\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│\u001b[43m \u001b[0m\u001b[43m        R3\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.31e+10\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.39e+11\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.00e+09\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m3.55e+07\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.64e+10\u001b[0m\u001b[43m \u001b[0m│\n",
-       "│         R5 │ 7.31e+05 │ 6.44e+03 │ 7.31e+05 │ 7.20e+05 │ 7.41e+05 │\n",
-       "│ sigma_imag │ 3.68e+04 │ 1.06e+02 │ 3.68e+04 │ 3.66e+04 │ 3.70e+04 │\n",
-       "│ sigma_real │ 4.95e+04 │ 1.24e+02 │ 4.95e+04 │ 4.93e+04 │ 4.97e+04 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-style: italic\">                 R1-[P2,[R3,P4]], 0/1000 divergences                 </span>\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">  Parameter </span>┃<span style=\"font-weight: bold\">     Mean </span>┃<span style=\"font-weight: bold\">      Std </span>┃<span style=\"font-weight: bold\">   Median </span>┃<span style=\"font-weight: bold\">     5.0% </span>┃<span style=\"font-weight: bold\">    95.0% </span>┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P2n │ 1.79e-01 │ 0.00e+00 │ 1.79e-01 │ 1.79e-01 │ 1.79e-01 │\n",
-       "│        P2w │ 4.13e-07 │ 0.00e+00 │ 4.13e-07 │ 4.13e-07 │ 4.13e-07 │\n",
-       "│        P4n │ 8.73e-01 │ 0.00e+00 │ 8.73e-01 │ 8.73e-01 │ 8.73e-01 │\n",
-       "│        P4w │ 1.40e-06 │ 1.14e-13 │ 1.40e-06 │ 1.40e-06 │ 1.40e-06 │\n",
-       "│         R1 │ 2.73e+02 │ 0.00e+00 │ 2.73e+02 │ 2.73e+02 │ 2.73e+02 │\n",
-       "│         R3 │ 1.19e+09 │ 0.00e+00 │ 1.19e+09 │ 1.19e+09 │ 1.19e+09 │\n",
-       "│ sigma_imag │ 1.77e+01 │ 0.00e+00 │ 1.77e+01 │ 1.77e+01 │ 1.77e+01 │\n",
-       "│ sigma_real │ 2.09e+01 │ 0.00e+00 │ 2.09e+01 │ 2.09e+01 │ 2.09e+01 │\n",
-       "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[3m                 R1-[P2,[R3,P4]], 0/1000 divergences                 \u001b[0m\n",
-       "┏━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m Parameter\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    Mean\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m     Std\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m  Median\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m    5.0%\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   95.0%\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
-       "│        P2n │ 1.79e-01 │ 0.00e+00 │ 1.79e-01 │ 1.79e-01 │ 1.79e-01 │\n",
-       "│        P2w │ 4.13e-07 │ 0.00e+00 │ 4.13e-07 │ 4.13e-07 │ 4.13e-07 │\n",
-       "│        P4n │ 8.73e-01 │ 0.00e+00 │ 8.73e-01 │ 8.73e-01 │ 8.73e-01 │\n",
-       "│        P4w │ 1.40e-06 │ 1.14e-13 │ 1.40e-06 │ 1.40e-06 │ 1.40e-06 │\n",
-       "│         R1 │ 2.73e+02 │ 0.00e+00 │ 2.73e+02 │ 2.73e+02 │ 2.73e+02 │\n",
-       "│         R3 │ 1.19e+09 │ 0.00e+00 │ 1.19e+09 │ 1.19e+09 │ 1.19e+09 │\n",
-       "│ sigma_imag │ 1.77e+01 │ 0.00e+00 │ 1.77e+01 │ 1.77e+01 │ 1.77e+01 │\n",
-       "│ sigma_real │ 2.09e+01 │ 0.00e+00 │ 2.09e+01 │ 2.09e+01 │ 2.09e+01 │\n",
+       "│\u001b[43m \u001b[0m\u001b[43m        L3\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m5.89e-20\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.79e-19\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m4.50e-21\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m6.35e-23\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.02e-19\u001b[0m\u001b[43m \u001b[0m│\n",
+       "│        P2n │ 6.27e-01 │ 1.40e-03 │ 6.27e-01 │ 6.25e-01 │ 6.29e-01 │\n",
+       "│        P2w │ 1.44e-06 │ 4.50e-09 │ 1.44e-06 │ 1.44e-06 │ 1.45e-06 │\n",
+       "│\u001b[43m \u001b[0m\u001b[43m        R1\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.36e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m2.96e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.35e+01\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m1.18e+00\u001b[0m\u001b[43m \u001b[0m│\u001b[43m \u001b[0m\u001b[43m7.83e+01\u001b[0m\u001b[43m \u001b[0m│\n",
+       "│         R4 │ 7.39e+06 │ 2.64e+04 │ 7.39e+06 │ 7.35e+06 │ 7.43e+06 │\n",
+       "│ sigma_imag │ 1.11e+04 │ 7.03e+01 │ 1.11e+04 │ 1.10e+04 │ 1.12e+04 │\n",
+       "│ sigma_real │ 1.11e+04 │ 7.55e+01 │ 1.11e+04 │ 1.10e+04 │ 1.13e+04 │\n",
        "└────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘\n"
       ]
      },
@@ -999,7 +671,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
@@ -1081,7 +753,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1148,7 +820,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.10.13"
   },
   "toc": {
    "base_numbering": 1,
diff --git a/pyproject.toml b/pyproject.toml
index aa5ad966..2ed5ce63 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -38,13 +38,15 @@ dependencies = [
     "ipywidgets",
     "jax",
     "julia",
+    "juliacall",
+    "juliapkg",
     "matplotlib",
     "mpire[dill]",
     "numpy",
     "numpyro",
     "pandas",
     "psutil",
-    "pyparsing",
+    "pyparsing >= 3",
     "rich",
     "scikit-learn >= 1.4",
     "seaborn",
@@ -82,6 +84,3 @@ testpaths = [
     "tests",
     "integration",
 ]
-
-[tool.ruff]
-line-length = 88
diff --git a/ruff.toml b/ruff.toml
new file mode 100644
index 00000000..acaef89e
--- /dev/null
+++ b/ruff.toml
@@ -0,0 +1,77 @@
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Same as Black.
+line-length = 92
+indent-width = 4
+
+# Assume Python 3.10
+target-version = "py310"
+
+[lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "F", "W"]
+ignore = []
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = true
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"


Test patch:
diff --git a/tests/test_backend.py b/tests/test_backend.py
index f610603d..a8675351 100644
--- a/tests/test_backend.py
+++ b/tests/test_backend.py
@@ -5,17 +5,29 @@
 
 def test_init_julia():
     Main = julia_helpers.init_julia()
-    assert Main.eval("1+1") == 2
+    assert Main.seval("1+1") == 2
 
 
 def test_import_julia_modules():
     Main = julia_helpers.init_julia()
 
     # Ensure installed modules can be imported
-    ec = julia_helpers.import_package("EquivalentCircuits", Main=Main)
-    # Test Main is not required
-    ec = julia_helpers.import_package("EquivalentCircuits")
+    ec = julia_helpers.import_package("EquivalentCircuits", Main)
+    assert hasattr(ec, "circuit_evolution")
 
-    # Throw error for non-existent module
+    # Throw error for non-existent module if error=True
     with pytest.raises(Exception):
-        julia_helpers.import_package("NonExistentModule", Main)
+        julia_helpers.import_package("NonExistentModule", Main, error=True)
+    # Otherwise, return None
+    ref = julia_helpers.import_package("NonExistentModule", Main, error=False)
+    assert ref is None
+
+
+def test_import_backend():
+    # Import backend with Julia runtime as argument
+    Main = julia_helpers.init_julia()
+    ec = julia_helpers.import_backend(Main)
+    assert hasattr(ec, "circuit_evolution")
+    # Import backend without Julia runtime as argument
+    ec = julia_helpers.import_backend()
+    assert hasattr(ec, "circuit_evolution")
diff --git a/tests/test_core.py b/tests/test_core.py
index 5dc110dd..32a49369 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -36,12 +36,13 @@ def test_gep_serial():
     kwargs = {
         "iters": 2,
         "complexity": 12,
-        "population_size": 10,
+        "population_size": 5,
         "generations": 5,
-        "tol": 1e-2,
+        "tol": 1e10,
         "parallel": False,
     }
     circuits = core.generate_equivalent_circuits(Z, freq, **kwargs)
+    assert len(circuits) == kwargs["iters"]
     assert isinstance(circuits, pd.DataFrame)
 
 
@@ -51,12 +52,13 @@ def test_gep_parallel():
     kwargs = {
         "iters": 2,
         "complexity": 12,
-        "population_size": 10,
+        "population_size": 5,
         "generations": 5,
-        "tol": 1e-2,
+        "tol": 1e10,
         "parallel": True,
     }
     circuits = core.generate_equivalent_circuits(Z, freq, **kwargs)
+    assert len(circuits) == kwargs["iters"]
     assert isinstance(circuits, pd.DataFrame)
 
 
diff --git a/tests/test_utils.py b/tests/test_utils.py
index f5e1652d..6f89d7c3 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -39,7 +39,8 @@ def test_generate_circuit_fn():
     p = np.random.rand(num_params)
     circuit_fn = utils.generate_circuit_fn(circuit)
     Z_py = circuit_fn(p, freq)
-    ec = julia_helpers.import_backend()
+    Main = julia_helpers.init_julia()
+    ec = julia_helpers.import_backend(Main)
     Z_jl = np.array([ec.get_target_impedance(circuit, p, f) for f in freq])
     np.testing.assert_allclose(Z_py, Z_jl)