2020-02-20 00:56:30 +01:00
|
|
|
|
#lang racket
|
|
|
|
|
|
|
|
|
|
;;; dds/networks
|
|
|
|
|
|
|
|
|
|
;;; This module provides some quick definitions for and analysing
|
|
|
|
|
;;; network models. A network is a set of variables which are updated
|
|
|
|
|
;;; according to their corresponding update functions. The variables
|
|
|
|
|
;;; to be updated at each step are given by the mode.
|
|
|
|
|
;;;
|
|
|
|
|
;;; This model can generalise Boolean networks, TBANs, multivalued
|
|
|
|
|
;;; networks, etc.
|
|
|
|
|
|
2020-02-23 12:10:27 +01:00
|
|
|
|
(require "utils.rkt" "generic.rkt" graph)
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
|
|
|
|
(provide
|
2020-02-23 11:10:18 +01:00
|
|
|
|
;; Structures
|
|
|
|
|
(struct-out dynamics)
|
2020-02-20 14:13:48 +01:00
|
|
|
|
;; Functions
|
2020-02-23 12:10:27 +01:00
|
|
|
|
(contract-out [update (-> network? state? (set/c variable? #:kind 'dont-care) state?)]
|
2020-02-20 00:56:30 +01:00
|
|
|
|
[make-state (-> (listof (cons/c symbol? any/c)) state?)]
|
2020-02-20 14:13:48 +01:00
|
|
|
|
[make-network-from-functions (-> (listof (cons/c symbol? update-function/c)) network?)]
|
|
|
|
|
[update-function-form->update-function (-> update-function-form? update-function/c)]
|
2020-02-20 00:56:30 +01:00
|
|
|
|
[network-form->network (-> network-form? network?)]
|
|
|
|
|
[make-network-from-forms (-> (listof (cons/c symbol? update-function-form?))
|
2020-02-20 15:17:32 +01:00
|
|
|
|
network?)]
|
2020-02-20 15:56:48 +01:00
|
|
|
|
[list-interactions (-> network-form? variable? (listof variable?))]
|
2020-02-22 22:27:40 +01:00
|
|
|
|
[build-interaction-graph (-> network-form? graph?)]
|
2020-02-23 09:12:01 +01:00
|
|
|
|
[build-all-states (-> domain-mapping/c (listof state?))]
|
2020-02-23 11:51:59 +01:00
|
|
|
|
[make-same-domains (-> (listof variable?) generic-set? domain-mapping/c)]
|
2020-02-23 00:15:18 +01:00
|
|
|
|
[make-boolean-domains (-> (listof variable?) (hash/c variable? (list/c #f #t)))]
|
2020-02-23 20:13:37 +01:00
|
|
|
|
[build-all-boolean-states (-> (listof variable?) (listof state?))]
|
2020-02-23 09:12:01 +01:00
|
|
|
|
[get-interaction-sign (-> network-form? domain-mapping/c variable? variable? (or/c '+ '- '0))]
|
2020-02-23 10:00:48 +01:00
|
|
|
|
[build-signed-interaction-graph (-> network-form? domain-mapping/c graph?)]
|
2020-02-23 11:25:19 +01:00
|
|
|
|
[build-boolean-signed-interaction-graph (-> network-form? graph?)]
|
|
|
|
|
[make-asyn (-> (listof variable?) mode?)]
|
2020-02-23 11:42:01 +01:00
|
|
|
|
[make-syn (-> (listof variable?) mode?)]
|
|
|
|
|
[make-dynamics-from-func (-> network? (-> (listof variable?) mode?) dynamics?)]
|
|
|
|
|
[make-asyn-dynamics (-> network? dynamics?)]
|
2020-02-23 12:19:47 +01:00
|
|
|
|
[make-syn-dynamics (-> network? dynamics?)]
|
2020-02-23 13:28:51 +01:00
|
|
|
|
[dds-step-one (-> dynamics? state? (set/c state?))]
|
2020-02-23 14:11:55 +01:00
|
|
|
|
[dds-step-one-annotated (-> dynamics? state? (set/c (cons/c modality? state?)))]
|
2020-02-23 18:51:57 +01:00
|
|
|
|
[dds-step (-> dynamics? (set/c state? #:kind 'dont-care) (set/c state?))]
|
|
|
|
|
[dds-build-state-graph (-> dynamics? (set/c state? #:kind 'dont-care) graph?)]
|
2020-02-23 19:24:53 +01:00
|
|
|
|
[dds-build-n-step-state-graph (-> dynamics? (set/c state? #:kind 'dont-care) number? graph?)]
|
2020-02-23 19:44:55 +01:00
|
|
|
|
[pretty-print-state (-> state? string?)]
|
|
|
|
|
[any->boolean (-> any/c boolean?)]
|
|
|
|
|
[pretty-print-boolean-state (-> state? string?)]
|
|
|
|
|
[pretty-print-state-graph-with (-> graph? (-> state? string?) graph?)]
|
|
|
|
|
[pretty-print-state-graph (-> graph? graph?)]
|
2020-02-23 20:13:37 +01:00
|
|
|
|
[pretty-print-boolean-state-graph (-> graph? graph?)]
|
|
|
|
|
[build-full-boolean-state-graph (-> dynamics? graph?)])
|
2020-02-20 14:13:48 +01:00
|
|
|
|
;; Predicates
|
|
|
|
|
(contract-out [variable? (-> any/c boolean?)]
|
|
|
|
|
[state? (-> any/c boolean?)]
|
|
|
|
|
[update-function-form? (-> any/c boolean?)]
|
2020-02-23 11:10:18 +01:00
|
|
|
|
[network-form? (-> any/c boolean?)]
|
2020-02-23 13:53:02 +01:00
|
|
|
|
[modality? (-> any/c boolean?)]
|
2020-02-23 11:10:18 +01:00
|
|
|
|
[mode? (-> any/c boolean?)])
|
2020-02-20 00:56:30 +01:00
|
|
|
|
;; Contracts
|
2020-02-22 10:37:37 +01:00
|
|
|
|
(contract-out [state/c contract?]
|
|
|
|
|
[network/c contract?]
|
2020-02-23 09:12:01 +01:00
|
|
|
|
[update-function/c contract?]
|
|
|
|
|
[domain-mapping/c contract?])
|
2020-02-20 00:56:30 +01:00
|
|
|
|
;; Syntax
|
2020-02-23 19:44:55 +01:00
|
|
|
|
st nn ppsg ppsgb)
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;;; =================
|
|
|
|
|
;;; Basic definitions
|
|
|
|
|
;;; =================
|
|
|
|
|
|
|
|
|
|
(define variable? symbol?)
|
|
|
|
|
|
|
|
|
|
;;; A state of a network is a mapping from the variables of the
|
|
|
|
|
;;; network to their values.
|
|
|
|
|
(define state? variable-mapping?)
|
|
|
|
|
(define state/c (flat-named-contract 'state state?))
|
|
|
|
|
|
|
|
|
|
;;; An update function is a function computing a value from the given
|
|
|
|
|
;;; state.
|
2020-02-20 14:13:48 +01:00
|
|
|
|
(define update-function/c (-> state? any/c))
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
|
|
|
|
;;; A network is a mapping from its variables to its update functions.
|
|
|
|
|
(define network? variable-mapping?)
|
|
|
|
|
(define network/c (flat-named-contract 'network network?))
|
|
|
|
|
|
|
|
|
|
;;; Given a state s updates all the variables from xs. This
|
|
|
|
|
;;; corresponds to a parallel mode.
|
2020-02-23 09:19:45 +01:00
|
|
|
|
(define (update network s xs)
|
|
|
|
|
(for/fold ([new-s s])
|
|
|
|
|
([x xs])
|
|
|
|
|
(let ([f (hash-ref network x)])
|
|
|
|
|
(hash-set new-s x (f s)))))
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
2020-02-23 08:47:16 +01:00
|
|
|
|
;;; A version of make-immutable-hash restricted to creating network
|
|
|
|
|
;;; states (see contract).
|
2020-02-22 23:20:10 +01:00
|
|
|
|
(define (make-state mappings) (make-immutable-hash mappings))
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
|
|
|
|
;;; A shortcut for make-state.
|
|
|
|
|
(define-syntax-rule (st mappings) (make-state mappings))
|
|
|
|
|
|
2020-02-23 08:47:16 +01:00
|
|
|
|
;;; A version of make-immutable-hash restricted to creating networks.
|
2020-02-22 23:22:43 +01:00
|
|
|
|
(define (make-network-from-functions funcs) (make-immutable-hash funcs))
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;;; =================================
|
|
|
|
|
;;; Syntactic description of networks
|
|
|
|
|
;;; =================================
|
|
|
|
|
|
|
|
|
|
;;; An update function form is any form which can appear as a body of
|
|
|
|
|
;;; a function and which can be evaluated with eval. For example,
|
|
|
|
|
;;; '(and x y (not z)) or '(+ 1 a (- b 10)).
|
|
|
|
|
(define update-function-form? any/c)
|
|
|
|
|
|
|
|
|
|
;;; A Boolean network form is a mapping from its variables to the
|
|
|
|
|
;;; forms of their update functions.
|
|
|
|
|
(define network-form? variable-mapping?)
|
|
|
|
|
|
|
|
|
|
;;; Build an update function from an update function form.
|
|
|
|
|
(define (update-function-form->update-function form)
|
2020-02-20 15:36:29 +01:00
|
|
|
|
(λ (s) (eval-with s form)))
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
|
|
|
|
;;; Build a network from a network form.
|
|
|
|
|
(define (network-form->network bnf)
|
2020-02-23 08:57:50 +01:00
|
|
|
|
(for/hash ([(x form) bnf])
|
|
|
|
|
(values x (update-function-form->update-function form))))
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
|
|
|
|
;;; Build a network from a list of pairs of forms of update functions.
|
|
|
|
|
(define (make-network-from-forms forms)
|
2020-02-22 23:22:43 +01:00
|
|
|
|
(network-form->network (make-immutable-hash forms)))
|
2020-02-20 00:56:30 +01:00
|
|
|
|
|
|
|
|
|
;;; A shortcut for make-network-from-forms.
|
|
|
|
|
(define-syntax-rule (nn forms) (make-network-from-forms forms))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;;; ============================
|
|
|
|
|
;;; Inferring interaction graphs
|
|
|
|
|
;;; ============================
|
|
|
|
|
|
|
|
|
|
;;; I allow any syntactic forms in definitions of Boolean functions.
|
|
|
|
|
;;; I can still find out which Boolean variables appear in those
|
|
|
|
|
;;; syntactic form, but I have no reliable syntactic means of finding
|
|
|
|
|
;;; out what kind of action do they have (inhibition or activation)
|
|
|
|
|
;;; since I cannot do Boolean minimisation (e.g., I cannot rely on not
|
|
|
|
|
;;; appearing before a variable, since (not (not a)) is equivalent
|
|
|
|
|
;;; to a). On the other hand, going through all Boolean states is
|
|
|
|
|
;;; quite resource-consuming and thus not always useful.
|
|
|
|
|
;;;
|
|
|
|
|
;;; In this section I provide inference of both unsigned and signed
|
|
|
|
|
;;; interaction graphs, but since the inference of signed interaction
|
|
|
|
|
;;; graphs is based on analysing the dynamics of the networks, it may
|
|
|
|
|
;;; be quite resource-consuming.
|
2020-02-20 15:17:32 +01:00
|
|
|
|
|
|
|
|
|
;;; Lists the variables of the network form appearing in the update
|
|
|
|
|
;;; function form for x.
|
|
|
|
|
(define (list-interactions nf x)
|
|
|
|
|
(set-intersect
|
|
|
|
|
(extract-symbols (hash-ref nf x))
|
|
|
|
|
(hash-keys nf)))
|
2020-02-20 15:56:48 +01:00
|
|
|
|
|
|
|
|
|
;;; Builds the graph in which the vertices are the variables of a
|
|
|
|
|
;;; given network, and which contains an arrow from a to b whenever a
|
|
|
|
|
;;; appears in (list-interactions a).
|
|
|
|
|
(define (build-interaction-graph n)
|
|
|
|
|
(transpose
|
|
|
|
|
(unweighted-graph/adj
|
2020-02-23 08:57:50 +01:00
|
|
|
|
(for/list ([(var _) n]) (cons var (list-interactions n var))))))
|
2020-02-22 22:27:40 +01:00
|
|
|
|
|
2020-02-23 09:12:01 +01:00
|
|
|
|
;;; A domain mapping is a hash set mapping variables to the lists of
|
|
|
|
|
;;; values in their domains.
|
|
|
|
|
(define domain-mapping/c (hash/c variable? list?))
|
|
|
|
|
|
2020-02-23 09:09:43 +01:00
|
|
|
|
;;; Given a hash-set mapping variables to generic sets of their
|
2020-02-22 22:27:40 +01:00
|
|
|
|
;;; possible values, constructs the list of all possible states.
|
|
|
|
|
(define (build-all-states vars-domains)
|
2020-02-23 09:09:43 +01:00
|
|
|
|
(let* ([var-dom-list (hash->list vars-domains)]
|
|
|
|
|
[vars (map car var-dom-list)]
|
|
|
|
|
[domains (map cdr var-dom-list)])
|
2020-02-22 22:27:40 +01:00
|
|
|
|
(for/list ([s (apply cartesian-product domains)])
|
|
|
|
|
(make-state (for/list ([var vars] [val s])
|
|
|
|
|
(cons var val))))))
|
2020-02-22 22:41:56 +01:00
|
|
|
|
|
2020-02-23 00:13:36 +01:00
|
|
|
|
;;; Makes a hash set mapping all variables to a single domain.
|
2020-02-23 00:15:18 +01:00
|
|
|
|
(define (make-same-domains vars domain)
|
2020-02-23 08:57:50 +01:00
|
|
|
|
(for/hash ([var vars]) (values var domain)))
|
2020-02-23 00:13:36 +01:00
|
|
|
|
|
|
|
|
|
;;; Makes a hash set mapping all variables to the Boolean domain.
|
2020-02-23 00:15:18 +01:00
|
|
|
|
(define (make-boolean-domains vars)
|
|
|
|
|
(make-same-domains vars '(#f #t)))
|
2020-02-23 00:13:36 +01:00
|
|
|
|
|
2020-02-23 20:13:37 +01:00
|
|
|
|
;;; Builds all boolean states possible over a given set of variables.
|
|
|
|
|
(define (build-all-boolean-states vars)
|
|
|
|
|
(build-all-states (make-boolean-domains vars)))
|
|
|
|
|
|
2020-02-23 00:04:19 +01:00
|
|
|
|
;;; Given two interacting variables of a network form and the domains
|
|
|
|
|
;;; of the variables, returns '+ if the interaction is monotonously
|
|
|
|
|
;;; increasing, '- if it is monotonously decreasing, and '0 otherwise.
|
|
|
|
|
;;;
|
|
|
|
|
;;; This function does not check whether the two variables indeed
|
|
|
|
|
;;; interact. Its behaviour is undefined if the variables do not
|
|
|
|
|
;;; interact.
|
|
|
|
|
;;;
|
|
|
|
|
;;; /!\ This function iterates through almost all of the states of the
|
|
|
|
|
;;; network, so its performance decreases very quickly with network
|
|
|
|
|
;;; size.
|
|
|
|
|
(define (get-interaction-sign network-form doms x y)
|
|
|
|
|
(let* ([dom-x (hash-ref doms x)]
|
|
|
|
|
[dom-y (hash-ref doms y)]
|
|
|
|
|
[network (network-form->network network-form)]
|
|
|
|
|
;; Replace the domain of x by a dummy singleton.
|
|
|
|
|
[doms-no-x (hash-set doms x '(#f))]
|
|
|
|
|
;; Build all the states, but as if x were not there: since I
|
|
|
|
|
;; replace its domain by a singleton, all states will contain
|
|
|
|
|
;; the same value for x.
|
2020-02-23 09:09:43 +01:00
|
|
|
|
[states-no-x (build-all-states doms-no-x)]
|
2020-02-23 00:04:19 +01:00
|
|
|
|
;; Go through all states, then through all ordered pairs of
|
|
|
|
|
;; values of x, generate pairs of states (s1, s2) such that x
|
|
|
|
|
;; has a smaller value in s1, and check that updating y in s1
|
|
|
|
|
;; yields a smaller value than updating y in s2. I rely on
|
|
|
|
|
;; the fact that the domains are ordered.
|
|
|
|
|
[x-y-interactions (for*/list ([s states-no-x]
|
|
|
|
|
[x1 dom-x] ; ordered pairs of values of x
|
|
|
|
|
[x2 (cdr (member x1 dom-x))])
|
|
|
|
|
(let* ([s1 (hash-set s x x1)] ; s1(x) < s2(x)
|
|
|
|
|
[s2 (hash-set s x x2)]
|
|
|
|
|
[y1 ((hash-ref network y) s1)]
|
|
|
|
|
[y2 ((hash-ref network y) s2)])
|
|
|
|
|
;; y1 <= y2?
|
|
|
|
|
(<= (index-of dom-y y1) (index-of dom-y y2))))])
|
|
|
|
|
(cond
|
|
|
|
|
;; If, in all interactions, y1 <= y2, then we have an
|
|
|
|
|
;; increasing/promoting interaction between x and y.
|
|
|
|
|
[(andmap (λ (x) (eq? x #t)) x-y-interactions) '+]
|
|
|
|
|
;; If, in all interactions, y1 > y2, then we have an
|
|
|
|
|
;; decreasing/inhibiting interaction between x and y.
|
|
|
|
|
[(andmap (λ (x) (eq? x #f)) x-y-interactions) '-]
|
|
|
|
|
;; Otherwise the interaction is neither increasing nor
|
|
|
|
|
;; decreasing.
|
|
|
|
|
[else '0])))
|
2020-02-23 01:00:09 +01:00
|
|
|
|
|
|
|
|
|
;;; Constructs a signed interaction graph of a given network form,
|
|
|
|
|
;;; given the ordered domains of its variables. The order on the
|
|
|
|
|
;;; domains determines the signs which will appear on the interaction
|
|
|
|
|
;;; graph.
|
|
|
|
|
;;;
|
|
|
|
|
;;; /!\ This function iterates through almost all states of the
|
|
|
|
|
;;; network for every arrow in the unsigned interaction graph, so its
|
|
|
|
|
;;; performance decreases very quickly with the size of the network.
|
|
|
|
|
(define (build-signed-interaction-graph network-form doms)
|
|
|
|
|
(let ([ig (build-interaction-graph network-form)])
|
|
|
|
|
(weighted-graph/directed
|
|
|
|
|
(for/list ([e (in-edges ig)])
|
|
|
|
|
(match-let ([(list x y) e])
|
|
|
|
|
(list (match (get-interaction-sign network-form doms x y)
|
|
|
|
|
['+ 1] ['- -1] ['0 0])
|
|
|
|
|
x y))))))
|
2020-02-23 10:00:48 +01:00
|
|
|
|
|
|
|
|
|
;;; Calls build-signed-interaction-graph with the Boolean domain for
|
|
|
|
|
;;; all variable.
|
|
|
|
|
;;;
|
|
|
|
|
;;; /!\ The same performance warning applies as for
|
|
|
|
|
;;; build-signed-interaction-graph.
|
|
|
|
|
(define (build-boolean-signed-interaction-graph network-form)
|
|
|
|
|
(build-signed-interaction-graph network-form
|
|
|
|
|
(make-boolean-domains (hash-keys network-form))))
|
2020-02-23 11:10:18 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;;; ====================
|
|
|
|
|
;;; Dynamics of networks
|
|
|
|
|
;;; ====================
|
|
|
|
|
|
|
|
|
|
;;; This section contains definitions for building and analysing the
|
|
|
|
|
;;; dynamics of networks.
|
|
|
|
|
|
2020-02-23 13:53:02 +01:00
|
|
|
|
;;; A modality is a set of variable.
|
|
|
|
|
(define modality? (set/c variable?))
|
|
|
|
|
|
|
|
|
|
;;; A mode is a set of modalities.
|
|
|
|
|
(define mode? (set/c modality?))
|
2020-02-23 11:10:18 +01:00
|
|
|
|
|
|
|
|
|
;;; A network dynamics is a network plus a mode.
|
2020-02-23 12:19:47 +01:00
|
|
|
|
(struct dynamics (network mode)
|
|
|
|
|
#:methods gen:dds
|
2020-02-23 12:23:55 +01:00
|
|
|
|
[(define/match (dds-step-one dyn s)
|
2020-02-23 12:19:47 +01:00
|
|
|
|
[((dynamics network mode) s)
|
2020-02-23 14:11:55 +01:00
|
|
|
|
(for/set ([m mode]) (update network s m))])
|
|
|
|
|
|
|
|
|
|
;; Annotates each result state with the modality which lead to it.
|
|
|
|
|
(define/match (dds-step-one-annotated dyn s)
|
|
|
|
|
[((dynamics network mode) s)
|
|
|
|
|
(for/set ([m mode]) (cons m (update network s m)))])])
|
2020-02-23 11:25:19 +01:00
|
|
|
|
|
|
|
|
|
;;; Given a list of variables, builds the asynchronous mode (a set of
|
|
|
|
|
;;; singletons).
|
|
|
|
|
(define (make-asyn vars)
|
|
|
|
|
(for/set ([v vars]) (set v)))
|
|
|
|
|
|
|
|
|
|
;;; Given a list of variables, builds the synchronous mode (a set
|
|
|
|
|
;;; containing the set of variables).
|
|
|
|
|
(define (make-syn vars) (set (list->set vars)))
|
2020-02-23 11:42:01 +01:00
|
|
|
|
|
|
|
|
|
;;; Given a network, applies a function for building a mode to its
|
|
|
|
|
;;; variables and returns the corresponding network dynamics.
|
|
|
|
|
(define (make-dynamics-from-func network mode-func)
|
|
|
|
|
(dynamics network (mode-func (hash-keys network))))
|
|
|
|
|
|
|
|
|
|
;;; Creates the asynchronous dynamics for a given network.
|
|
|
|
|
(define (make-asyn-dynamics network)
|
|
|
|
|
(make-dynamics-from-func network make-asyn))
|
|
|
|
|
|
|
|
|
|
;;; Creates the synchronous dynamics for a given network.
|
|
|
|
|
(define (make-syn-dynamics network)
|
|
|
|
|
(make-dynamics-from-func network make-syn))
|
2020-02-23 19:24:53 +01:00
|
|
|
|
|
|
|
|
|
;;; Pretty-prints a state of the network.
|
|
|
|
|
(define (pretty-print-state s)
|
|
|
|
|
(string-join (for/list ([(key val) s]) (format "~a:~a" key val))))
|
2020-02-23 19:44:55 +01:00
|
|
|
|
|
|
|
|
|
;;; Converts any non-#f value to 1 and #f to 0.
|
|
|
|
|
(define (any->boolean x) (if x 1 0))
|
|
|
|
|
|
|
|
|
|
;;; Pretty-prints a state of the network to Boolean values 0 or 1.
|
|
|
|
|
(define (pretty-print-boolean-state s)
|
|
|
|
|
(string-join (for/list ([(key val) s]) (format "~a:~a" key (any->boolean val)))))
|
|
|
|
|
|
|
|
|
|
;;; Given a state graph and a pretty-printer for states build a new
|
|
|
|
|
;;; state graph with pretty-printed vertices.
|
|
|
|
|
(define (pretty-print-state-graph-with gr pprinter)
|
|
|
|
|
(update-vertices/unweighted gr pprinter))
|
|
|
|
|
|
|
|
|
|
;;; Pretty prints a state graph with pretty-print-state.
|
|
|
|
|
(define (pretty-print-state-graph gr)
|
|
|
|
|
(pretty-print-state-graph-with gr pretty-print-state))
|
|
|
|
|
|
|
|
|
|
;;; A shortcut for pretty-print-state-graph.
|
|
|
|
|
(define-syntax-rule (ppsg gr) (pretty-print-state-graph gr))
|
|
|
|
|
|
|
|
|
|
;;; Pretty prints a state graph with pretty-print-boolean-state.
|
|
|
|
|
(define (pretty-print-boolean-state-graph gr)
|
|
|
|
|
(pretty-print-state-graph-with gr pretty-print-boolean-state))
|
|
|
|
|
|
|
|
|
|
;;; A shortcut for pretty-print-boolean-state-graph.
|
|
|
|
|
(define-syntax-rule (ppsgb gr) (pretty-print-boolean-state-graph gr))
|
2020-02-23 20:13:37 +01:00
|
|
|
|
|
|
|
|
|
;;; Builds the full state graph of a Boolean network.
|
|
|
|
|
(define (build-full-boolean-state-graph dyn)
|
|
|
|
|
(dds-build-state-graph
|
|
|
|
|
dyn
|
|
|
|
|
(list->set (build-all-boolean-states (hash-keys (dynamics-network dyn))))))
|