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/thresholdbased 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
or1
.
__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
andthresholds
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]
SingleNode 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 onedimensional sequence of node states
 index – the index to update (or None)
 pin – the indices to pin (or None)
 values – a dictionary of indexvalue pairs to set after update
Returns: the updated states
Raises:  ValueError – if
states
is not in the network’s state space  ValueError – if
index
andpin
are both provided  ValueError – if
index
andvalues
are both provided  ValueError – if an element of
pin
is a key invalues
 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_pombenodes.txt' >>> edges_path = '../neet/boolean/data/s_pombeedges.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:

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 aWTNetwork
.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
andpygraphviz
.Supported image formats are determined by
graphviz
. In particular, pdf support requirescairo
andpango
to be installed prior tographviz
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
orWTNetwork
 filename – filename to write drawing to. Temporary filename will be used if no filename provided.
Returns: a
pygraphviz
network drawing labels – how node is labeled and thus identified in networkx
graph (‘names’ or ‘indices’), only used if network is
a

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
andstates
are iterable, then apply the above function to each pair(x,y) in zip(values, states)
and stores the result instates
.If
values
andstates
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 thresholdshifted values of each node
 states – the preupdated 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
andstates
are iterable, then apply the above function to each pair(x,y) in zip(values, states)
and stores the result instates
.If
values
andstates
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 thresholdshifted values of each node
 states – the preupdated 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
andstates
are iterable, then apply the above function to each pair(x,y) in zip(values, states)
and stores the result instates
.If
values
andstates
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 thresholdshifted values of each node
 states – the preupdated states of the nodes
Returns: the updated states

Logicbased 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
or1
.
__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 atindex
. Ifindex
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 welldefined 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 subtables of logic conditions for every node. Each subtable nominates a node and its logically connected nodes in par enthesis as a comment line:
# A (B C)
The rest of the subtable are states of those nodes in parenthesis
(B, C)
that would activate the state of A. States that would deactivateA
should not be included in the subtable.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/myeloidtruth_table.txt' >>> net = LogicNetwork.read_table(myeloid_path) >>> net.size 11 >>> net.names ['GATA2', 'GATA1', 'FOG1', 'EKLF', 'Fli1', 'SCL', 'C/EBPa', 'PU.1', 'cJun', 'EgrNab', 'Gfi1']
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 optionalexternal_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 equationA = A
, for its state stays on or off unless being set externally, but now the node had to be excluded fromexternal_nodes_path
to avoid duplication and confusion.Examples
>>> myeloid_path = '../neet/boolean/data/myeloidlogic_expressions.txt' >>> net = LogicNetwork.read_logic(myeloid_path) >>> net.size 11 >>> net.names ['GATA2', 'GATA1', 'FOG1', 'EKLF', 'Fli1', 'SCL', 'C/EBPa', 'PU.1', 'cJun', 'EgrNab', 'Gfi1']
Parameters:  logic_path (str) – path to a file of logial expressions
 external_nodes_path (str) – a path to a file of external nodes
Returns:

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
andpygraphviz
.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 aLogicNetwork
orneet.boolean.WTNetwork
 filename – filename to write drawing to. Temporary filename will be used if no filename provided.
Returns: a
pygraphviz
network drawing labels – how node is labeled and thus identified in networkx
graph (

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 aneet.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 convertReturns: an equivalent neet.boolean.LogicNetwork
Random networks¶

neet.boolean.randomnet.
random_logic
(logic_net, p=0.5, connections='fixedstructure', fix_external=False, make_irreducible=False, fix_canalizing=False)[source]¶ Return a
LogicNetwork
from an inputLogicNetwork
with a random logic table.connections
decides how a node in the random network is connected to other nodes:'fixedstructure'
 the random network has the same connections as the input network.
'fixedindegree'
 the number of connections to a node is the same as the input network, but the connections are randomly selected.
'fixedmeandegree'
 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. Ifp
is a single number, it applies to all nodes. Otherwisep
must be a sequence of numbers that match in size with the input network.>>> net = random_logic(myeloid, connections='fixedstructure') >>> neighbors_in(net) == neighbors_in(myeloid) True >>> neighbors_out(net) == neighbors_out(myeloid) True
>>> net = random_logic(myeloid, connections='fixedindegree') >>> in_degree(net) == in_degree(myeloid) True >>> out_degree(net) == out_degree(myeloid) False
>>> net = random_logic(myeloid, connections='fixedmeandegree') >>> 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) –
'fixedstructure'
,'fixedindegree'
,'fixedmeandegree'
, or'free'
Returns: a random
neet.boolean.LogicNetwork
Example Networks¶
The examples module provides a collection of preloaded 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.