Boolean Networks

The neet.boolean module provides network types (WTNetwork and LogicNetwork) and functions for simulating Boolean network modules.

API Documentation

Weight/Threshold Networks

class neet.boolean.WTNetwork(weights, thresholds=None, names=None, theta=None)[source]

The WTNetwork class represents weight/threshold-based boolean networks. As such it is specified in terms of a matrix of edge weights (rows are target nodes) and a vector of node thresholds, and each node of the network is expected to be in either of two states 0 or 1.

__init__(weights, thresholds=None, names=None, theta=None)[source]

Construct a network from weights and thresholds.

Examples

>>> net = WTNetwork([[1,0],[1,1]])
>>> net.size
2
>>> net.weights
array([[1., 0.],
       [1., 1.]])
>>> net.thresholds
array([0., 0.])
>>> net = WTNetwork([[1,0],[1,1]], [0.5,-0.5])
>>> net.size
2
>>> net.weights
array([[1., 0.],
       [1., 1.]])
>>> net.thresholds
array([ 0.5, -0.5])
>>> net = WTNetwork(3)
>>> net.size
3
>>> net.weights
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])
>>> net.thresholds
array([0., 0., 0.])
Parameters:
  • weights – the network weights, where: source/column -> target/row
  • thresholds – the network thresholds
  • names – the names of the network nodes (optional)
Parma theta:

the threshold function to use

Raises:
  • ValueError – if weights is empty
  • ValueError – if weights is not a square matrix
  • ValueError – if thresholds is not a vector
  • ValueError – if weights and thresholds have different dimensions
  • ValueError – if len(names) is not equal to the number of nodes
  • TypeError – if threshold_func is not callable
size

The number of nodes in the network.

>>> net = WTNetwork(5)
>>> net.size
5
>>> WTNetwork(0)
Traceback (most recent call last):
    ...
ValueError: invalid network size
Type:int
state_space()[source]

Return a neet.statespace.StateSpace object for the network.

>>> net = WTNetwork(3)
>>> net.state_space()
<neet.statespace.StateSpace object at 0x...>
>>> space = net.state_space()
>>> list(space)
[[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]]
Returns:the network’s neet.statespace.StateSpace
update(states, index=None, pin=None, values=None)[source]

Update states, in place, according to the network update rules.

Basic Use

>>> s_pombe.size
9
>>> xs = [0,0,0,0,1,0,0,0,0]
>>> s_pombe.update(xs)
[0, 0, 0, 0, 0, 0, 0, 0, 1]
>>> s_pombe.update(xs)
[0, 1, 1, 1, 0, 0, 1, 0, 0]

Single-Node Update

>>> xs = [0,0,0,0,1,0,0,0,0]
>>> s_pombe.update(xs, index=-1)
[0, 0, 0, 0, 1, 0, 0, 0, 1]
>>> s_pombe.update(xs, index=2)
[0, 0, 1, 0, 1, 0, 0, 0, 1]
>>> s_pombe.update(xs, index=3)
[0, 0, 1, 1, 1, 0, 0, 0, 1]

State Pinning

>>> s_pombe.update([0,0,0,0,1,0,0,0,0], pin=[-1])
[0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> s_pombe.update([0,0,0,0,0,0,0,0,1], pin=[1])
[0, 0, 1, 1, 0, 0, 1, 0, 0]
>>> s_pombe.update([0,0,0,0,0,0,0,0,1], pin=range(1,4))
[0, 0, 0, 0, 0, 0, 1, 0, 0]
>>> s_pombe.update([0,0,0,0,0,0,0,0,1], pin=[1,2,3,-1])
[0, 0, 0, 0, 0, 0, 1, 0, 1]

Value Fixing

>>> s_pombe.update([0,0,0,0,1,0,0,0,0], values={0:1, 2:1})
[1, 0, 1, 0, 0, 0, 0, 0, 1]
>>> s_pombe.update([0,0,0,0,0,0,0,0,1], values={0:1, 1:0, 2:0})
[1, 0, 0, 1, 0, 0, 1, 0, 0]
>>> s_pombe.update([0,0,0,0,0,0,0,0,1], values={-1:1, -2:1})
[0, 1, 1, 1, 0, 0, 1, 1, 1]

Erroneous Usage

>>> s_pombe.update([0,0,0])
Traceback (most recent call last):
    ...
ValueError: incorrect number of states in array
>>> s_pombe.update([0,0,0,0,2,0,0,0,0])
Traceback (most recent call last):
    ...
ValueError: invalid node state in states
>>> s_pombe.update([0,0,0,0,1,0,0,0,0], 9)
Traceback (most recent call last):
    ...
IndexError: index 9 is out of bounds for axis 0 with size 9
>>> s_pombe.update([0,0,0,0,1,0,0,0,0], index=-1, pin=[-1])
Traceback (most recent call last):
    ...
ValueError: cannot provide both the index and pin arguments
>>> s_pombe.update([0,0,0,0,1,0,0,0,0], pin=[10])
Traceback (most recent call last):
    ...
IndexError: index 10 is out of bounds for axis 1 with size 9
>>> s_pombe.update([0,0,0,0,1,0,0,0,0], index=1, values={1:0,3:0,2:1})
Traceback (most recent call last):
    ...
ValueError: cannot provide both the index and values arguments
>>> s_pombe.update([0,0,0,0,1,0,0,0,0], pin=[1], values={1:0,3:0,2:1})
Traceback (most recent call last):
    ...
ValueError: cannot set a value for a pinned state
>>> s_pombe.update([0,0,0,0,1,0,0,0,0], values={1:2})
Traceback (most recent call last):
    ...
ValueError: invalid state in values argument
Parameters:
  • states – the one-dimensional sequence of node states
  • index – the index to update (or None)
  • pin – the indices to pin (or None)
  • values – a dictionary of index-value pairs to set after update
Returns:

the updated states

Raises:
  • ValueError – if states is not in the network’s state space
  • ValueError – if index and pin are both provided
  • ValueError – if index and values are both provided
  • ValueError – if an element of pin is a key in values
  • ValueError – if a value in values is not binary (0 or 1)
static read(nodes_path, edges_path)[source]

Read a network from a pair of node/edge files.

>>> nodes_path = '../neet/boolean/data/s_pombe-nodes.txt'
>>> edges_path = '../neet/boolean/data/s_pombe-edges.txt'
>>> net = WTNetwork.read(nodes_path, edges_path)
>>> net.size
9
>>> net.names
['SK', 'Cdc2_Cdc13', 'Ste9', 'Rum1', 'Slp1', 'Cdc2_Cdc13_active', 'Wee1_Mik1', 'Cdc25', 'PP']
Parameters:
  • nodes_path (str) – path to the nodes file
  • edges_path (str) – path to the edges file
Returns:

a WTNetwork

neighbors_in(index)[source]

Return the set of all neighbor nodes, where edge(neighbor_node–>index) exists. An important consideration is that some threshold functions can introduce implicit dependence between nodes, e.g. WTNetwork.split_threshold().

Parameters:index – node index
Returns:the set of all node indices which point toward the index node

Examples

>>> net = WTNetwork([[0,0,0],[1,0,1],[0,1,0]],
... theta=WTNetwork.split_threshold)
>>> [net.neighbors_in(node) for node in range(net.size)]
[{0}, {0, 1, 2}, {1, 2}]
>>> net.theta = WTNetwork.negative_threshold
>>> [net.neighbors_in(node) for node in range(net.size)]
[set(), {0, 2}, {1}]
neighbors_out(index)[source]

Return the set of all neighbor nodes, where edge(index–>neighbor_node) exists.

Parameters:index – node index
Returns:the set of all node indices which the index node points to

Basic Use

>>> net = WTNetwork([[0,0,0],[1,0,1],[0,1,0]],
... theta=WTNetwork.split_threshold)
>>> [net.neighbors_out(node) for node in range(net.size)]
[{0, 1}, {1, 2}, {1, 2}]
>>> net.theta = WTNetwork.negative_threshold
>>> [net.neighbors_out(node) for node in range(net.size)]
[{1}, {2}, {1}]
neighbors(index)[source]

Return a set of neighbors for a specified node, or a list of sets of neighbors for all nodes in the network.

Parameters:index – node index
Returns:a set (if index!=None) or list of sets of neighbors of a node or network or nodes
>>> net = WTNetwork([[0,0,0],[1,0,1],[0,1,0]],
... theta=WTNetwork.split_threshold)
>>> [net.neighbors(node) for node in range(net.size)]
[{0, 1}, {0, 1, 2}, {1, 2}]
>>> net.theta = WTNetwork.negative_threshold
>>> [net.neighbors(node) for node in range(net.size)]
[{1}, {0, 2}, {1}]
to_networkx_graph(labels='indices')[source]

Return networkx graph given neet network. Return a networkx graph from a WTNetwork.

Parameters:labels – how nodes are labeled and thus identified in networkx graph ('names' or 'indices')
Returns:a networkx.DiGraph
draw(labels='indices', filename=None)[source]

Output a file with a simple network drawing.

Requires networkx and pygraphviz.

Supported image formats are determined by graphviz. In particular, pdf support requires cairo and pango to be installed prior to graphviz installation.

Parameters:
  • labels – how node is labeled and thus identified in networkx graph (‘names’ or ‘indices’), only used if network is a neet.boolean.LogicNetwork or WTNetwork
  • filename – filename to write drawing to. Temporary filename will be used if no filename provided.
Returns:

a pygraphviz network drawing

static split_threshold(values, states)[source]

Applies the following functional form to the arguments:

\[\begin{split}\theta_s(x,y) = \begin{cases} 0 & x < 0 \\ y & x = 0 \\ 1 & x > 0. \end{cases}\end{split}\]

If values and states are iterable, then apply the above function to each pair (x,y) in zip(values, states) and stores the result in states.

If values and states are scalar values, then simply apply the above threshold function to the pair (values, states) and return the result.

Examples

>>> ys = [0,0,0]
>>> WTNetwork.split_threshold([1, -1, 0], ys)
[1, 0, 0]
>>> ys
[1, 0, 0]
>>> ys = [1,1,1]
>>> WTNetwork.split_threshold([1, -1, 0], ys)
[1, 0, 1]
>>> ys
[1, 0, 1]
>>> WTNetwork.split_threshold(0,0)
0
>>> WTNetwork.split_threshold(0,1)
1
>>> WTNetwork.split_threshold(1,0)
1
>>> WTNetwork.split_threshold(1,1)
1
Parameters:
  • values – the threshold-shifted values of each node
  • states – the pre-updated states of the nodes
Returns:

the updated states

static negative_threshold(values, states)[source]

Applies the following functional form to the arguments:

\[\begin{split}\theta_n(x) = \begin{cases} 0 & x \leq 0 \\ 1 & x > 0. \end{cases}\end{split}\]

If values and states are iterable, then apply the above function to each pair (x,y) in zip(values, states) and stores the result in states.

If values and states are scalar values, then simply apply the above threshold function to the pair (values, states) and return the result.

Examples

>>> ys = [0,0,0]
>>> WTNetwork.negative_threshold([1, -1, 0], ys)
[1, 0, 0]
>>> ys
[1, 0, 0]
>>> ys = [1,1,1]
>>> WTNetwork.negative_threshold([1, -1, 0], ys)
[1, 0, 0]
>>> ys
[1, 0, 0]
>>> WTNetwork.negative_threshold(0,0)
0
>>> WTNetwork.negative_threshold(0,1)
0
>>> WTNetwork.negative_threshold(1,0)
1
>>> WTNetwork.negative_threshold(1,1)
1
Parameters:
  • values – the threshold-shifted values of each node
  • states – the pre-updated states of the nodes
Returns:

the updated states

static positive_threshold(values, states)[source]

Applies the following functional form to the arguments:

\[\begin{split}\theta_p(x) = \begin{cases} 0 & x < 0 \\ 1 & x \geq 0. \end{cases}\end{split}\]

If values and states are iterable, then apply the above function to each pair (x,y) in zip(values, states) and stores the result in states.

If values and states are scalar values, then simply apply the above threshold function to the pair (values, states) and return the result.

Examples

>>> ys = [0,0,0]
>>> WTNetwork.positive_threshold([1, -1, 0], ys)
[1, 0, 1]
>>> ys
[1, 0, 1]
>>> ys = [1,1,1]
>>> WTNetwork.positive_threshold([1, -1, 0], ys)
[1, 0, 1]
>>> ys
[1, 0, 1]
>>> WTNetwork.positive_threshold(0,0)
1
>>> WTNetwork.positive_threshold(0,1)
1
>>> WTNetwork.positive_threshold(1,0)
1
>>> WTNetwork.positive_threshold(-1,0)
0
Parameters:
  • values – the threshold-shifted values of each node
  • states – the pre-updated states of the nodes
Returns:

the updated states

Logic-based Networks

class neet.boolean.LogicNetwork(table, names=None, reduced=False)[source]

The LogicNetwork class represents boolean networks whose update rules follow logic relations among nodes. Each node state is expressed as 0 or 1.

__init__(table, names=None, reduced=False)[source]

Construct a network from a logic truth table.

A truth table stores a list of tuples, one for each node in order. A tuple of the form (A, {C1, C2, …}) at index i provides the activation conditions for the node of index i. A is a tuple marking the indices of the nodes which influence the state of node i via logic relations. {C1, C2, …} is a set, each element of which is the collection of binary states of these influencing nodes that would activate node i, setting it to 1. Any other collection of states of nodes in A are assumed to deactivate node i, setting it to 0.

C1, C2, etc. are sequences (tuple or str) of binary digits, each being the binary state of corresponding node in A.

Examples

>>> net = LogicNetwork([((0,), {'0'})])
>>> net.size
1
>>> net.table
[((0,), {'0'})]
>>> net = LogicNetwork([((1,), {'0', '1'}), ((0,), {'1'})])
>>> net.size
2
>>> net.table == [((1,), {'0', '1'}), ((0,), {'1'})]
True
>>> net = LogicNetwork([((1, 2), {'01', '10'}),
... ((0, 2), ((0, 1), '10', [1, 1])),
... ((0, 1), {'11'})], ['A', 'B', 'C'])
>>> net.size
3
>>> net.names
['A', 'B', 'C']
>>> net.table == [((1, 2), {'01', '10'}),
... ((0, 2), {'01', '11', '10'}), ((0, 1), {'11'})]
True
Parameters:
  • table – the logic table
  • names – names of nodes, default None
size

The number of nodes in the network.

>>> net = LogicNetwork([((1, 2), {'01', '10'}),
... ((0, 2), {'01', '10', '11'}), ((0, 1), {'11'})])
>>> net.size
3
Type:int
state_space()[source]

Return a neet.statespace.StateSpace object for the network.

>>> net = LogicNetwork([((1, 2), {'01', '10'}),
... ((0, 2), {'01', '10', '11'}), ((0, 1), {'11'})])
>>> net.state_space()
<neet.statespace.StateSpace object at 0x...>
>>> space = net.state_space()
>>> list(space)
[[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]]
Returns:the network’s neet.statespace.StateSpace
update(net_state, index=None, pin=None, values=None)[source]

Update node states according to the truth table.

If index is provided, only update the node at index. If index is not provided, update all ndoes. pin provides the indices of which the nodes’ states are forced to remain unchanged.

Examples

>>> net = LogicNetwork([((0,), {'0'})])
>>> net.update([0], 0)
[1]
>>> net.update([1])
[0]
>>>
>>> net = LogicNetwork([((1,), {'0', '1'}), ((0,), {'1'})])
>>> net.update([1, 0], 0)
[1, 0]
>>> net.update([1, 0], 1)
[1, 1]
>>> net.update([0, 0])
[1, 0]
>>> net = LogicNetwork([((1, 2), {'01', '10'}),
... ((0, 2), {(0, 1), '10', (1, 1)}),
... ((0, 1), {'11'})])
>>> net.size
3
>>> net.update([0, 0, 1], 1)
[0, 1, 1]
>>> net.update([0, 1, 0])
[1, 0, 0]
>>> net.update([0, 0, 1])
[1, 1, 0]
>>> net.update([0, 0, 1], pin=[1])
[1, 0, 0]
>>> net.update([0, 0, 1], pin=[0, 1])
[0, 0, 0]
>>> net.update([0, 0, 1], values={0: 0})
[0, 1, 0]
>>> net.update([0, 0, 1], pin=[1], values={0: 0})
[0, 0, 0]
Parameters:
  • net_state (sequence) – a sequence of binary node states
  • index (int or None) – the index to update (or None)
  • pin (sequence) – the indices to pin (or None)
  • values (dict) – override values
Returns:

the updated states

reduce_table()[source]

Reduce truth table by removing input nodes which have no logic influence from the truth table of each node.

Note

This function introduces the identity function for all nodes which have no inputs. This ensure that every node has a well-defined logical function. The example below demonstrates this with node 1.

>>> net = LogicNetwork([((0,1), {'00', '10'}), ((0,), {'0', '1'})])
>>> net.table == [((0,1), {'00', '10'}), ((0,), {'0', '1'})]
True
>>> net.reduce_table()
>>> net.table == [((1,), {'0'}), ((1,), {'1'})]
True
classmethod read_table(table_path, reduced=False)[source]

Read a network from a truth table file.

A logic table file starts with a table title which contains names of all nodes. It is a line marked by ## at the begining with node names seperated by commas or spaces. This line is required. For artificial network without node names, arbitrary names must be put in place, e.g.:

## A B C D

Following are the sub-tables of logic conditions for every node. Each sub-table nominates a node and its logically connected nodes in par- enthesis as a comment line:

# A (B C)

The rest of the sub-table are states of those nodes in parenthesis (B, C) that would activate the state of A. States that would deactivate A should not be included in the sub-table.

A complete logic table with 3 nodes A, B, C would look like this:

## A B C
# A (B C)
1 0
1 1
# B (A)
1
# C (B C A)
1 0 1
0 1 0
0 1 1

Custom comments can be added above or below the table title (as long as they are preceeded with more or less than two # (eg # or ### but not ##)).

Examples:

>>> myeloid_path = '../neet/boolean/data/myeloid-truth_table.txt'
>>> net = LogicNetwork.read_table(myeloid_path)
>>> net.size
11
>>> net.names
['GATA-2', 'GATA-1', 'FOG-1', 'EKLF', 'Fli-1', 'SCL', 'C/EBPa', 'PU.1', 'cJun', 'EgrNab', 'Gfi-1']
Parameters:table_path (str) – a path to a table table file
Returns:a LogicNetwork
classmethod read_logic(logic_path, external_nodes_path=None, reduced=False)[source]

Read a network from a file of logic equations.

A logic equations has the form of A = B AND ( C OR D ), each term being separated from parantheses and logic operators with at least a space. The optional external_nodes_path takes a file that contains nodes in a column whose states do not depend on any nodes. These are considered “external” nodes. Equivalently, such a node would have a logic equation A = A, for its state stays on or off unless being set externally, but now the node had to be excluded from external_nodes_path to avoid duplication and confusion.

Examples

>>> myeloid_path = '../neet/boolean/data/myeloid-logic_expressions.txt'
>>> net = LogicNetwork.read_logic(myeloid_path)
>>> net.size
11
>>> net.names
['GATA-2', 'GATA-1', 'FOG-1', 'EKLF', 'Fli-1', 'SCL', 'C/EBPa', 'PU.1', 'cJun', 'EgrNab', 'Gfi-1']
Parameters:
  • logic_path (str) – path to a file of logial expressions
  • external_nodes_path (str) – a path to a file of external nodes
Returns:

a LogicNetwork

neighbors_in(index)[source]

Return the set of all neighbor nodes, where edge(neighbor_node–>index) exists.

Examples

>>> net = LogicNetwork([((1, 2), {'11', '10'}),
... ((0,), {'1'}),
... ((0, 1, 2), {'010', '011', '101'}),
... ((3,), {'1'})])
>>> [net.neighbors_in(node) for node in range(net.size)]
[{1, 2}, {0}, {0, 1, 2}, {3}]
Parameters:index – node index
Returns:the set of all node indices which point toward the index node
neighbors_out(index)[source]

Return the set of all neighbor nodes, where edge(index–>neighbor_node) exists.

Examples

>>> net = LogicNetwork([((1, 2), {'11', '10'}),
... ((0,), {'1'}),
... ((0, 1, 2), {'010', '011', '101'}),
... ((3,), {'1'})])
>>> [net.neighbors_out(node) for node in range(net.size)]
[{1, 2}, {0, 2}, {0, 2}, {3}]
Parameters:index – node index
Returns:the set of all node indices which the index node points to
neighbors(index)[source]

Return a set of neighbors for a specified node, or a list of sets of neighbors for all nodes in the network.

Examples

>>> net = LogicNetwork([((1, 2), {'11', '10'}),
... ((0,), {'1'}),
... ((0, 1, 2), {'010', '011', '101'}),
... ((3,), {'1'})])
>>> [net.neighbors(node) for node in range(net.size)]
[{1, 2}, {0, 2}, {0, 1, 2}, {3}]
Parameters:index – node index
Returns:a set of neighbors of a node
to_networkx_graph(labels='indices')[source]

Return networkx graph given neet network.

Parameters:labels – how node is labeled and thus identified in networkx graph ('names' or 'indices')
Returns:a networkx.DiGraph
draw(labels='indices', filename=None)[source]

Output a file with a simple network drawing.

Requires networkx and pygraphviz.

Supported image formats are determined by graphviz. In particular, pdf support requires 'cairo' and 'pango' to be installed prior to graphviz installation.

Parameters:
  • labels – how node is labeled and thus identified in networkx graph ('names' or 'indices'), only used if network is a LogicNetwork or neet.boolean.WTNetwork
  • filename – filename to write drawing to. Temporary filename will be used if no filename provided.
Returns:

a pygraphviz network drawing

Network Type Conversion

Some algorithms are more efficiently implemented on particular network type. This module allows the user to convert between network types, though not all conversions are possible. For example, not every neet.boolean.LogicNetwork can be converted to a neet.boolean.WTNetwork, though the reverse direction is always possible.

neet.boolean.conv.wt_to_logic(net)[source]

Convert a neet.boolean.WTNetwork to a neet.boolean.LogicNetwork.

Examples

>>> s_pombe_logical = wt_to_logic(s_pombe)
>>> isinstance(s_pombe_logical, LogicNetwork)
True
>>> transitions(s_pombe_logical) == transitions(s_pombe)
True
Parameters:net (neet.boolean.WTNetwork) – a network to convert
Returns:an equivalent neet.boolean.LogicNetwork

Random networks

neet.boolean.randomnet.random_logic(logic_net, p=0.5, connections='fixed-structure', fix_external=False, make_irreducible=False, fix_canalizing=False)[source]

Return a LogicNetwork from an input LogicNetwork with a random logic table.

connections decides how a node in the random network is connected to other nodes:

'fixed-structure'
the random network has the same connections as the input network.
'fixed-in-degree'
the number of connections to a node is the same as the input network, but the connections are randomly selected.
'fixed-mean-degree'
the total number of edges is conserved, but edges are placed randomly between nodes.
'free'
only the number of nodes is conserved, with the number of connections to a node chosen uniformly between 1 and the total number of nodes.

p is the probability of a state of the connected nodes being present in the activation table. It is also equavolent to the probability of any node being activated. If p is a single number, it applies to all nodes. Otherwise p must be a sequence of numbers that match in size with the input network.

>>> net = random_logic(myeloid, connections='fixed-structure')
>>> neighbors_in(net) == neighbors_in(myeloid)
True
>>> neighbors_out(net) == neighbors_out(myeloid)
True
>>> net = random_logic(myeloid, connections='fixed-in-degree')
>>> in_degree(net) == in_degree(myeloid)
True
>>> out_degree(net) == out_degree(myeloid)
False
>>> net = random_logic(myeloid, connections='fixed-mean-degree')
>>> mean_degree(net) == mean_degree(myeloid)
True
Parameters:
  • logic_net – a neet.boolean.LogicNetwork
  • p (number or sequence) – probability that a state is present in the activation table
  • connections (str) – 'fixed-structure', 'fixed-in-degree', 'fixed-mean-degree', or 'free'
Returns:

a random neet.boolean.LogicNetwork

Example Networks

The examples module provides a collection of pre-loaded model networks such as s_pombe (fission yeast) and s_cerevisiae (budding yeast).

neet.boolean.examples.s_pombe = <neet.boolean.WTNetwork object>

The cell cycle network for S. pombe (fission yeast).

neet.boolean.examples.s_cerevisiae = <neet.boolean.WTNetwork object>

The cell cycle network for S. cerevisiae (budding yeast).

neet.boolean.examples.c_elegans = <neet.boolean.WTNetwork object>

The cell cycle network for C. elegans.

neet.boolean.examples.p53_no_dmg = <neet.boolean.WTNetwork object>

The p53 GRN with no damage present.

neet.boolean.examples.p53_dmg = <neet.boolean.WTNetwork object>

The p53 GRN with damage present.

neet.boolean.examples.mouse_cortical_7B = <neet.boolean.LogicNetwork object>

The gene regulatory network for mouse cortical (7B edges)

neet.boolean.examples.mouse_cortical_7C = <neet.boolean.LogicNetwork object>

The gene regulatory network for mouse cortical (7C edges)

neet.boolean.examples.myeloid = <neet.boolean.LogicNetwork object>

Differentiation control network for myeloid progenitors.