CRN

The synkit.CRN package provides SynKit’s chemical reaction network layer. It supports CRN construction from rules or curated pathway data, normalized network representation through SynCRN, symmetry-aware comparison, stoichiometric and thermodynamic summaries, and pathway-level analysis such as reachability and realizability.

Key CRN submodules include:

• Construct — expand rule systems into reaction-network digraphs

• Query — retrieve and curate KEGG-derived reaction collections

• Structure — represent CRNs as normalized SynCRN objects

• Symmetry — canonicalization and isomorphism for CRN comparison

• Props — stoichiometric, thermodynamic, and dynamical summaries

• Pathway — reachability, path-finding, and realizability analysis

Construct

Expand rule sets into reaction-network digraphs and convert them into normalized SynCRN objects.

Query

Retrieve KEGG pathway content, curate incomplete entries, and prepare pathway-derived CRN inputs.

Symmetry

Canonicalize and compare CRNs through isomorphism and symmetry-aware structural analysis.

Construct

The synkit.CRN.Construct package expands reaction rules into a reaction-network digraph, which can then be converted into a normalized SynCRN object.

This layer is useful when you want to generate a CRN from:

• a seed pool of starting molecules

• a rule set

• repeated rule applications

• frontier-based exploration with deduplication

Expand a CRN from seeds and rules, then convert to SynCRN

from synkit.CRN.Construct.DAG.crn import CRNExpand
from synkit.CRN.Structure.syncrn import SynCRN

dg = CRNExpand(
    rules=RULES,
    repeats=repeats,
    explicit_h=False,
    implicit_temp=False,
    keep_aam=False,
    use_frontier=True,
    dedup_delta=True,
)

g = dg.build(seeds=SEEDS, parallel=False)
syn = SynCRN.from_digraph(g)

print(syn.n_species)
print(syn.n_reactions)

Example output

42
67

Query

The synkit.CRN.Query package provides KEGG-oriented retrieval and curation utilities. It is the natural entry point when your CRN comes from a biological pathway rather than from rule-based expansion.

Key helpers include:

• KEGGExtractor

• KEGGImputer

• KEGGClient

Example: retrieve a KEGG pathway as structured JSON

Extract KEGG pathway content for downstream CRN work

from synkit.CRN.Query.kegg_extract import KEGGExtractor

pathway_data = KEGGExtractor().build_pathway_json(
    "hsa00010",
    with_compounds=True,
    with_atom_maps=True,
    save_as="Data/KEGG/hsa00010_raw.json",
)

pathway_data

This query layer is especially useful when you want to:

• retrieve pathway reaction entries

• keep compound metadata together with reactions

• atom-map pathway reactions when possible

• patch incomplete records before building a final CRN

Structure

The synkit.CRN.Structure package provides the main normalized CRN representation used throughout SynKit.

The core object is:

• SynCRN

with supporting structural components:

• Species

• Reaction

• Rule

A SynCRN object is the preferred representation when you want:

• stable species and reaction ordering

• table-like and graph-like interoperability

• conversion to digraph or Petri-net views

• downstream symmetry, property, and pathway analysis

Build and inspect a SynCRN object

from synkit.CRN.Structure.syncrn import SynCRN

syn = SynCRN.from_reaction_strings([
    "A + B >> C",
    "C >> D",
])

print(syn)
print(syn.n_species)
print(syn.n_reactions)

Symmetry

The synkit.CRN.Symmetry package supports CRN isomorphism and canonicalization. This is the right layer when you want to compare two networks independently of their original labeling.

Relevant modules include:

• isomorphism

• canon

• automorphism

• wl_canon

Typical use cases:

• test whether two CRNs are structurally equivalent

• compute deterministic canonical forms

• compare rule-expanded and pathway-curated networks

• perform symmetry-aware downstream analysis

Compare two CRNs by isomorphism and canonicalization

from synkit.CRN.Structure.syncrn import SynCRN
from synkit.CRN.Symmetry.isomorphism import crn_isomorphic
from synkit.CRN.Symmetry.canon import canonicalize_crn

syn1 = SynCRN.from_reaction_strings([
    "A + B >> C",
    "C >> D",
])

syn2 = SynCRN.from_reaction_strings([
    "X + Y >> Z",
    "Z >> W",
])

print(crn_isomorphic(syn1, syn2))

can1 = canonicalize_crn(syn1)
can2 = canonicalize_crn(syn2)

print(can1 == can2)

Example output

True
True

Props

The synkit.CRN.Props package provides quantitative summaries and analysis layers on top of a normalized CRN.

Important modules include:

• stoich

• thermo

• dynamics

• helper

This layer is useful for computing:

• stoichiometric summaries and matrices

• thermodynamic annotations or aggregate summaries

• symbolic dynamical quantities such as Jacobian structure

• helper statistics over species and reactions

Example: stoichiometric analysis

Compute stoichiometric summaries from a SynCRN

from synkit.CRN.Structure.syncrn import SynCRN
from synkit.CRN.Props.stoich import compute_stoich_summary

syn = SynCRN.from_reaction_strings([
    "A + B >> C",
    "C >> D",
])

stoich = compute_stoich_summary(syn)
print(stoich)

Example: thermodynamic summary

Compute thermodynamic summary information

from synkit.CRN.Props.thermo import compute_thermo_summary

thermo = compute_thermo_summary(syn)
print(thermo)

Example: Jacobian or dynamical structure

Compute symbolic dynamical structure

from synkit.CRN.Props.dynamics import compute_jacobian_structure

J = compute_jacobian_structure(syn)
print(J)

Note

Exact function names may vary slightly across versions, but the Props package is the correct place for stoichiometric, thermodynamic, and Jacobian-style CRN analysis.

Pathway

The synkit.CRN.Pathway package provides pathway-level reasoning on top of a CRN. This is the right layer when you want to analyze whether a target is merely connected in the graph or actually reachable and realizable from a specified starting pool.

Relevant modules include:

• reachability

• realizability

• pathfinder

Typical questions addressed here are:

• which species are reachable from a given seed set?

• can a target route actually be realized under mass-conserving progression?

• which subset of reactions supports a target product?

Example: reachability

Reachable species from a starting set

from synkit.CRN.Structure.syncrn import SynCRN
from synkit.CRN.Pathway.reachability import reachable_species

syn = SynCRN.from_reaction_strings([
    "A + B >> C",
    "C >> D",
    "E >> F",
])

reached = reachable_species(syn, seeds={"A", "B"})
print(reached)

Example: realizability

Test whether a target can be realized from an initial pool

from synkit.CRN.Pathway.realizability import is_realizable

ok = is_realizable(syn, seeds={"A", "B"}, targets={"D"})
print(ok)

Example output

True

Recommended workflow

A practical CRN workflow in SynKit is:

1. Construct a CRN from rules, or Query a curated pathway source such as KEGG

2. Convert the result into SynCRN

3. Use Props to inspect stoichiometric, thermodynamic, or dynamical features

4. Use Pathway to analyze reachability and realizability

5. Use Symmetry when you need canonicalization or structural comparison

See Also

• Synthesis — rule application and multi-step generation workflows

• Graph — graph matching, ITS, MTG, and canonicalization utilities

• Chem — chemical validation, standardization, and balancing

• IO — conversion between graph and chemical representations