synkit 1.6.5__tar.gz → 1.7.0__tar.gz

synkit-1.7.0/.gitignore

@@ -0,0 +1,154 @@
+# Python bytecode, environments, and tool caches
+**/__pycache__/
+*.py[cod]
+.coverage
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.tox/
+.venv/
+venv/
+*cachedir
+*/catboost_info/
+
+# Build and generated documentation output
+/build/
+/dist/
+/docs/
+*.egg-info/
+# Optional Mapper kernel artifacts are rebuilt from the shipped C++ source.
+libsynkit_distance_*.so
+libsynkit_distance_*.json
+libsynkit_mapper_*.so
+libsynkit_mapper_*.dylib
+libsynkit_mapper_*.dll
+libsynkit_mapper_*.json
+
+# Generated logs, reports, notebooks, and data files
+*.log
+*.pdf
+*.rdf
+*.ipynb
+!Experiment/CRN/notebooks/crn_glycolysis_case_study.ipynb
+*.csv
+*.json
+*.json.gz
+*.pkl.gz
+*.txt
+!synkit/Chem/Mapper/solvers/native/cpp/CMakeLists.txt
+!synkit/Graph/Canon/cpp/CMakeLists.txt
+!synkit/Synthesis/Reactor/cpp/CMakeLists.txt
+libsynkit_partial_*.so
+libsynkit_partial_*.dylib
+libsynkit_partial_*.dll
+libsynkit_partial_*.json
+!synkit/CRN/cpp/CMakeLists.txt
+!synkit/CRN/Construct/cpp/CMakeLists.txt
+!synkit/CRN/Construct/dpo_cpp/CMakeLists.txt
+!synkit/Chem/Mapper/solvers/native/cpp/**/CMakeLists.txt
+!synkit/Chem/Mapper/solvers/native/cpp/src/symmetry/vendor/nauty/LICENSE-2.0.txt
+
+# Package resources and repository evidence retained despite the broad rules
+!/CMakeLists.txt
+!Experiment/CRN/LICENSES/*.txt
+!Experiment/CRN/environments/*.txt
+!Data/Conformance/stereomolgraph_graph_conformance.json
+!Data/Mech/polar.json
+!Data/Mech/radical.json
+!Data/Mech/stereo.json
+!Data/Schema/
+!Data/Schema/attribute_propagation_v1_5.json
+!/scripts/python_file_size_baseline.json
+!Test/Synthesis/Reactor/fixtures/small_rewrite_conformance.json
+!Test/Synthesis/Reactor/fixtures/wildcard_conformance.json
+!Test/Synthesis/Reactor/fixtures/wildcard_real_examples.json
+!Test/Synthesis/Reactor/fixtures/wildcard_observed_examples.json
+!Test/Synthesis/Reactor/fixtures/wildcard_symbolic_example.json
+!Test/Synthesis/Reactor/fixtures/wildcard_aromatic_examples.json
+
+# Lewis benchmark inputs and reviewed evidence
+!Experiment/Lewis/Data/all.csv
+!Experiment/Lewis/Data/benchmark.json.gz
+!Experiment/Lewis/Data/combinatorial_all.csv
+!Experiment/Lewis/Data/hydrogen.pkl.gz
+!Experiment/Lewis/mech_path/Data/MechanismBench/electrocyclic_machinery.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/polar.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/radical.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/stereo.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/stereo_branch_coverage.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/stereo_couplings.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/evidence/mechanismbench_evidence.json
+!Experiment/Lewis/mech_path/Data/reconstruction_audit/polar-failures.csv
+!Experiment/Lewis/mech_path/Data/reconstruction_audit/radical-arrow-review.csv
+!Experiment/Lewis/mech_path/Data/reconstruction_audit/radical-failures.csv
+!Experiment/Lewis/rule_replay/Data/bidirectional-replay/results.json
+!Experiment/Lewis/rule_replay/Data/relative-lone-pair/results.json
+
+# Stereo benchmark inputs and reproducible reports
+!Experiment/Stereo/Data/**/*.csv
+!Experiment/Stereo/Data/**/*.json
+!Experiment/Stereo/Data/manifest.json
+!Experiment/Stereo/Data/Perception/full_detection_report.json
+!Experiment/Stereo/Data/Perception/perception_conformance_cases.json
+
+# Historical reaction-stereo records consumed by experiment audits
+!Experiment/StereoReaction/evidence/stereo_rxn_closeout.json
+!Experiment/StereoReaction/evidence/stereo_rxn_validation.json
+
+# Large or reproducible data products
+/Data/Benchmark/*
+!/Data/Benchmark/mech/
+/Data/Benchmark/mech/*
+!/Data/Benchmark/mech/README.md
+!/Data/Benchmark/mech/polar-failures.csv
+!/Data/Benchmark/mech/radical-failures.csv
+!/Data/Benchmark/partial_expand/
+!/Data/Benchmark/partial_expand/**
+/Data/Benchmark/partial_expand/results/
+!/Data/Benchmark/Stereo/
+!/Data/Benchmark/Stereo/**
+/Data/Fragment/*
+/Data/Study/CRN/case_formose/*
+/Data/USPTO/*
+/Experiment/Lewis/Runs/
+
+# Resumable local benchmark state
+/Experiment/RBL/*checkpoint*.jsonl
+
+# Development and scratch paths
+/Experiment/atom_map/
+/Test/Conformance/
+/crn/
+/debug/
+/dev/
+# Manuscripts, evidence, figures, and local cleanup archives
+/paper/
+/sprint/
+/synkit/Graph/dev/
+
+# Local one-off scripts and prompts
+.gitignore
+measure_candidate_stages.py
+request.md
+run.sh
+run_rdcanon.py
+run_valid_bug_cases.py
+test_partial.py
+test_run.py
+test_syn.py
+test_syn_reactor.py
+
+# Local benchmark outputs and frozen source copies stay local.
+/benchmark_results/
+
+# Keep unreleased experiments local; publish only CRN and Lewis until release.
+/Experiment/*
+!/Experiment/CRN/
+!/Experiment/Lewis/
+!/Experiment/Autocatalytic/
+# Third-party simulation code of Higgs and Blackmond (Zenodo), not redistributed.
+/Experiment/Autocatalytic/Homochiral/higgs2025/
+!/Experiment/__init__.py
+
+# Experiment READMEs are local documentation, including nested directories.
+/Experiment/**/[Rr][Ee][Aa][Dd][Mm][Ee]*

synkit-1.7.0/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.20)
+project(synkit_native VERSION 1.7.0 LANGUAGES C CXX)
+
+option(SYNKIT_BUILD_MAPPER "Build the atom mapper and its solver backends" ON)
+option(SYNKIT_BUILD_CRN "Build exact chemical reaction network analysis" ON)
+option(SYNKIT_BUILD_CANON "Build graph and stereograph canonicalization" ON)
+option(SYNKIT_BUILD_PARTIAL "Build typed partial-rule application" ON)
+option(SYNKIT_NATIVE_WHEEL "Install native libraries into their Python packages" OFF)
+
+if(SYNKIT_NATIVE_WHEEL)
+  set(SYNKIT_MAPPER_WHEEL ON CACHE BOOL "Install mapper into the wheel" FORCE)
+  set(SYNKIT_CANON_WHEEL ON CACHE BOOL "Install canonicalization into the wheel" FORCE)
+  set(SYNKIT_PARTIAL_WHEEL ON CACHE BOOL "Install partial application into the wheel" FORCE)
+endif()
+
+enable_testing()
+if(SYNKIT_BUILD_MAPPER)
+  add_subdirectory(synkit/Chem/Mapper/solvers/native/cpp mapper)
+endif()
+if(SYNKIT_BUILD_CRN)
+  add_subdirectory(synkit/CRN/cpp crn)
+endif()
+if(SYNKIT_BUILD_CANON)
+  add_subdirectory(synkit/Graph/Canon/cpp canon)
+endif()
+if(SYNKIT_BUILD_PARTIAL)
+  add_subdirectory(synkit/Synthesis/Reactor/cpp partial)
+endif()

synkit-1.7.0/Experiment/CRN/LICENSES/KEGG.txt

@@ -0,0 +1,15 @@
+KEGG-derived cache notice
+=========================
+
+The file ``Experiment/CRN/data/kegg_modules.json`` contains records
+derived from the Kyoto Encyclopedia of Genes and Genomes (KEGG), retrieved on
+the date recorded inside that file. KEGG is copyright Kanehisa Laboratories.
+
+This cache is not covered by SynKit's MIT licence. KEGG's current terms state
+that academic users may use the KEGG website and that non-academic use requires
+a commercial licence. See: https://www.kegg.jp/kegg/legal.html
+
+Release maintainers must confirm that their intended redistribution of this
+cache is authorized under the applicable KEGG terms. If it is not, the cache
+must be excluded from the release and users must retrieve the source records
+under their own authorized access.

synkit-1.7.0/Experiment/CRN/__init__.py

@@ -0,0 +1,5 @@
+"""Chemical reaction network experiments.
+
+Experiments and shared fixtures live in studies; execution and checking helpers
+live in tools. Run the paper workload with run_all.py.
+"""

synkit-1.7.0/Experiment/CRN/environments/crn-1.7.0-linux.constraints.txt

@@ -0,0 +1,21 @@
+# Native CRN evidence environment, Linux x86_64, Python 3.12.12
+# Boost headers 1.90.0; RDKit C++ SDK 2026.03.1; C++17/C++20 toolchain.
+# Install project/test dependencies with pip -c this-file -e ".[test]" sympy
+numpy==2.4.4
+networkx==3.6.1
+scipy==1.17.0
+rdkit==2026.3.1
+sympy==1.14.0
+pytest==9.1.1
+matplotlib==3.10.8
+pandas==2.3.3
+seaborn==0.13.2
+requests==2.33.0
+scikit-learn==1.7.2
+joblib==1.5.3
+pillow==13.0.0
+regex==2026.4.4
+tqdm==4.67.1
+hatchling==1.31.0
+build==1.5.0
+psutil==7.2.2

synkit-1.7.0/Experiment/CRN/environments/crnt4sbml-requirements.txt

@@ -0,0 +1,26 @@
+crnt4sbml==0.0.15
+cycler==0.11.0
+decorator==4.4.2
+descartes==1.1.0
+kiwisolver==1.4.5
+matplotlib==3.1.1
+mizani==0.6.0
+mpmath==1.3.0
+networkx==2.3
+numpy==1.16.4
+palettable==3.3.3
+pandas==1.0.4
+patsy==0.5.1
+pip==24.0
+plotnine==0.6.0
+pyparsing==2.4.7
+python-dateutil==2.8.2
+python-libsbml==5.18.0
+pytz==2019.3
+scipy==1.4.1
+setuptools==67.8.0
+six==1.17.0
+statsmodels==0.10.2
+sympy==1.4
+typing_extensions==4.7.1
+wheel==0.42.0

synkit-1.7.0/Experiment/CRN/environments/formose-dpo.rst

@@ -0,0 +1,80 @@
+Formose DPO reproduction
+=======================
+
+The benchmark is shipped with the SynKit source distribution. It uses the four
+mapped rules and two seed molecules defined in
+``Experiment/CRN/studies/formose_case_study.py``. It does not import manuscript
+scripts or archived result files. Native controller and typed DPO kernel builds
+are explicit, content-addressed, and fingerprinted in the report.
+
+Native prerequisites
+--------------------
+
+Install SynKit and its CRN environment constraints, a C++20 compiler, CMake >=
+3.20, and an RDKit C++ SDK with Boost headers and CMake configuration. The native
+controller uses RDKit for molecular IO and identity, and the SynKit DPO kernel
+for graph transformations. The SDK need not share an address space with the
+RDKit Python package. Set ``SYNKIT_RDKIT_CPP_DIR`` or pass ``--rdkit-dir``; no SDK
+is downloaded automatically. The reference SDK was RDKit 2026.03.1.
+
+From the unpacked source distribution, a short native check is::
+
+    python Experiment/CRN/studies/formose_dpo.py \
+      --rdkit-dir /path/to/rdkit-sdk --output-dir /tmp/formose-smoke \
+      --depths 1 2 3 4 --warmups 1 --repeats 2
+
+The complete native measurement workload is::
+
+    python Experiment/CRN/studies/formose_dpo.py \
+      --rdkit-dir /path/to/rdkit-sdk --output-dir /tmp/formose-native \
+      --depths 1 2 3 4 5 6 --warmups 3 --repeats 20
+
+Independent engine comparison
+-----------------------------
+
+Create a MØD environment using ``mod-environment.yml`` and a separate Python
+virtual environment using ``molfoundry-requirements.txt``. The pins fix the engine
+versions used for the comparison; they are not full operating-system lockfiles.
+MolFoundry is distributed through ``https://py.molfoundry.de/dl/``; its custom
+package index is included in the requirements file.
+The benchmark records the engine and Python versions actually executed. Neither
+external environment needs a SynKit installation or RDKit Python package;
+format translation and network canonicalization run in the main interpreter.
+
+Require all three engines with::
+
+    python Experiment/CRN/studies/formose_dpo.py \
+      --rdkit-dir /path/to/rdkit-sdk --output-dir /tmp/formose-three-tools \
+      --external --mod-python /path/to/mod-env/bin/python \
+      --molfoundry-python /path/to/molfoundry-env/bin/python \
+      --depths 1 2 3 4 5 6 --warmups 3 --repeats 20
+
+A missing requested engine, timeout, incomplete native expansion, unstable
+repetition, mismatching network, or source modification makes the report fail
+and the command return nonzero. Native-only runs explicitly set
+``cross_tool_equality_checked`` to false and cannot establish cross-tool
+agreement. The report writes one row for every requested engine and depth.
+
+Timing and verification
+-----------------------
+
+Each timed call prepares fresh seeds and rules and constructs the network through
+the tool's public API. Imports, native compilation, controller startup, fixed GML
+translation, graph export, and the independent molecular identity audit are
+outside timing. Warmups are distinct from measured samples. Only one expansion
+is active at once, with tool order rotated across repetitions and depths.
+
+On POSIX the default per-worker address-space bound is 8 GiB; Linux workers are
+pinned to one available CPU by default. The default timeout is 180 seconds per
+expansion, with separate startup and audit budgets. Limits and whether they are
+enforced are recorded. CPU affinity and address-space controls may differ on
+other platforms; benchmark times are machine-specific and must be regenerated.
+
+Canonicalization removes explicit hydrogen vertices and stereochemistry and
+compares full species sets and directed reactant/product multisets. Shared
+participants are retained, and stoichiometric multiplicities are counted. Every
+repetition must have the same snapshot hash. The report contains the exact rule
+inputs, source hashes, controller build manifest, all samples, full execution
+schedule, and separate snapshots for inspection. Completed depths 1--6 have
+reference species/reaction counts of 3/1, 5/4, 9/10, 37/44, 302/371, and
+10572/11239. These checks do not assert kinetic or thermodynamic equivalence.

synkit-1.7.0/Experiment/CRN/environments/mod-environment.yml

@@ -0,0 +1,7 @@
+name: synkit-crn-mod
+channels:
+  - jakobandersen
+  - conda-forge
+dependencies:
+  - python=3.12
+  - mod=1.0.0.75

synkit-1.7.0/Experiment/CRN/environments/molfoundry-requirements.txt

@@ -0,0 +1,3 @@
+# Independent formose DPO comparison; install in its own interpreter.
+--extra-index-url https://py.molfoundry.de/dl/
+molfoundry==0.1.11

synkit-1.7.0/Experiment/CRN/notebooks/crn_glycolysis_case_study.ipynb

@@ -0,0 +1,226 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "glycolysis-00",
+   "metadata": {},
+   "source": [
+    "# Glycolysis: a CRN case study\n",
+    "\n",
+    "This offline example uses the reviewed KEGG M00001 fixture. It reproduces the\n",
+    "cached reduced-network structural results and verifies a prescribed glycolytic\n",
+    "flux from one glucose token. Currency removal is an explicit model choice.\n",
+    "These calculations do not predict kinetic or physiological behaviour.\n",
+    "\n",
+    "See [the experiment commands](../../README.md) for the complete CRN studies.\n",
+    "\n",
+    "Production analyses use the C++ backend through the Python interface. Execution requires a C++17 compiler and local Boost headers. It does not download dependencies."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "glycolysis-01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import Counter\n",
+    "from pathlib import Path\n",
+    "from tempfile import gettempdir\n",
+    "import sys\n",
+    "\n",
+    "repo_root = next(\n",
+    "    path for path in (Path.cwd(), *Path.cwd().parents)\n",
+    "    if (path / \"pyproject.toml\").is_file() and (path / \"synkit\").is_dir()\n",
+    ")\n",
+    "if str(repo_root) not in sys.path:\n",
+    "    sys.path.insert(0, str(repo_root))\n",
+    "\n",
+    "from synkit.CRN import (\n",
+    "    build_native, native_backend, PathwayRealizability, conserved_moieties, crnt_summary, find_siphons,\n",
+    "    siphon_persistence_details, crn_from_sbml, crn_to_sbml,\n",
+    ")\n",
+    "from Experiment.CRN.studies import GLYCOLYSIS_FLUX, build_kegg_crn\n",
+    "from Experiment.CRN.studies.representation import execute\n",
+    "\n",
+    "library = build_native(Path(gettempdir()) / \"synkit-crn-notebook-native\", with_semiflows=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "glycolysis-02",
+   "metadata": {},
+   "source": [
+    "## Reduced network and exact structural results\n",
+    "\n",
+    "Remove the documented currency metabolites. The reduced network has 14 species,\n",
+    "15 directed reactions, deficiency one, three minimal conserved pools, and three\n",
+    "minimal siphons. Failure of the sufficient persistence test\n",
+    "does not establish extinction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "glycolysis-03",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with native_backend(library):\n",
+    "    crn = build_kegg_crn(\"M00001\", drop_currency=True)\n",
+    "    summary = crnt_summary(crn)\n",
+    "    moieties = conserved_moieties(crn)\n",
+    "    siphons = find_siphons(crn)\n",
+    "    persistence = siphon_persistence_details(crn)\n",
+    "\n",
+    "    assert (summary.n_species, summary.n_reactions, summary.deficiency) == (14, 15, 1)\n",
+    "    assert not summary.is_weakly_reversible\n",
+    "    assert len(moieties) == len(siphons) == 3\n",
+    "    assert persistence.complete and persistence.persistence_ok is False\n",
+    "    print({\n",
+    "        \"species\": summary.n_species, \"reactions\": summary.n_reactions,\n",
+    "        \"deficiency\": summary.deficiency, \"conserved_pools\": len(moieties),\n",
+    "        \"minimal_siphons\": len(siphons), \"sufficient_persistence\": persistence.persistence_ok,\n",
+    "    })"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "glycolysis-04",
+   "metadata": {},
+   "source": [
+    "## Prescribed glycolytic flux\n",
+    "\n",
+    "Request the prescribed reaction multiset from one alpha-D-glucose token. A positive\n",
+    "result supplies an ordered firing certificate. Search statistics may depend on\n",
+    "the implementation; the checks below concern the prescribed flux and execution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "glycolysis-05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with native_backend(library):\n",
+    "    initial_marking = {\"alpha-D-Glucose\": 1}\n",
+    "    checker = PathwayRealizability().load_syncrn_and_flow(\n",
+    "        crn, flow=dict(GLYCOLYSIS_FLUX), initial_marking=initial_marking,\n",
+    "        species=\"label\", reaction=\"label\",\n",
+    "    )\n",
+    "    checker.build_petri_net_from_flow()\n",
+    "    outcome = checker.realizability_result()\n",
+    "    assert outcome.status.value == \"realizable\"\n",
+    "    certificate = list(outcome.certificate)\n",
+    "    assert len(certificate) == sum(GLYCOLYSIS_FLUX.values()) == 15\n",
+    "    print({\"status\": outcome.status.value, \"firings\": len(certificate)})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "glycolysis-06",
+   "metadata": {},
+   "source": [
+    "## Independent inventory replay\n",
+    "\n",
+    "Replay the certificate against the stored reactant and product counts,\n",
+    "without calling the search's Petri-net firing methods. Every step must have its\n",
+    "reactants, all inventories must stay non-negative, and firing counts must equal\n",
+    "the requested flux."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "glycolysis-07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "marking = {sid: initial_marking.get(species.label, 0) for sid, species in crn.species.items()}\n",
+    "reactions = {reaction.label: reaction for reaction in crn.reactions.values()}\n",
+    "for label in certificate:\n",
+    "    reaction = reactions[label]\n",
+    "    assert all(marking[sid] >= count for sid, count in reaction.lhs.items())\n",
+    "    for sid, count in reaction.lhs.items():\n",
+    "        marking[sid] -= count\n",
+    "    for sid, count in reaction.rhs.items():\n",
+    "        marking[sid] += count\n",
+    "    assert all(count >= 0 for count in marking.values())\n",
+    "assert dict(Counter(certificate)) == dict(GLYCOLYSIS_FLUX)\n",
+    "final_inventory = {species.label: marking[sid] for sid, species in crn.species.items() if marking[sid]}\n",
+    "assert final_inventory[\"Pyruvate\"] == 2\n",
+    "print(final_inventory)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "glycolysis-08",
+   "metadata": {},
+   "source": [
+    "## Currency-retention control\n",
+    "\n",
+    "Retain currencies under the same glucose-only inventory and prescribed flux.\n",
+    "The currency-retaining model has an exhaustive negative result. This comparison\n",
+    "shows that the reduced-model certificate does not establish execution when\n",
+    "cofactor requirements are restored."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "glycolysis-09",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with native_backend(library):\n",
+    "    intact = build_kegg_crn(\"M00001\", drop_currency=False)\n",
+    "    control = execute(intact, dict(GLYCOLYSIS_FLUX), initial_marking)\n",
+    "    assert control[\"status\"] == \"unrealizable\" and control[\"exhaustive\"]\n",
+    "    print({\"currencies_retained\": True, \"species\": intact.n_species, \"status\": control[\"status\"]})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "glycolysis-10",
+   "metadata": {},
+   "source": [
+    "## Structural SBML round trip\n",
+    "\n",
+    "Serialize and reload the reduced network in memory, then compare all directed\n",
+    "reaction equations and structural invariants. The adapter exchanges supported\n",
+    "SBML Core structure. This example supplies no kinetic laws."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "glycolysis-11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with native_backend(library):\n",
+    "    sbml = crn_to_sbml(crn, model_id=\"kegg_m00001\")\n",
+    "    restored = crn_from_sbml(sbml)\n",
+    "    assert sorted(restored.to_equations(species=\"label\", include_id=False)) == sorted(\n",
+    "        crn.to_equations(species=\"label\", include_id=False)\n",
+    "    )\n",
+    "    restored_summary = crnt_summary(restored)\n",
+    "    assert (restored_summary.n_species, restored_summary.n_reactions, restored_summary.deficiency) == (14, 15, 1)\n",
+    "    print({\"sbml_round_trip\": \"verified\", \"species\": restored.n_species, \"reactions\": restored.n_reactions})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}