dds: A Home-made Toolkit for Discrete Dynamical Systems in Racket
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Sergiu Ivanov 38660cc0a5 sbn-interaction-graph: Use zero-edges and declare it in the contract. 2 months ago
example Minor updates to some figures. 2 months ago
scribblings utils.scrbl: Add eval-with. 11 months ago
LICENSE Add the GNU GPL licence file. 2 years ago
README.org Move submitting =update-graph= higher on the list of priorities. 5 months ago
functions.rkt functions: Always use named test-cases in tests. 1 year ago
generic.rkt generic: Use collect-by-key/sets to collect the labels for state graphs. 2 years ago
info.rkt Rename manual → dds. 11 months ago
networks.rkt sbn-interaction-graph: Use zero-edges and declare it in the contract. 2 months ago
rs.rkt rs: Add pretty-print-reduced-state-graph. 11 months ago
utils.rkt Remove hash-intersect. 6 months ago

README.org

dds: A Home-made Toolkit for Discrete Dynamical Systems in Racket

This is a toolkit for playing with various discrete dynamical systems in Racket. A discrete dynamical system is a system which evolves from a discrete state to some other discrete states (many or one). The systems are discrete in the sense that we can identify successive states with no other states in between. Equivalently, the phase state of the system is discrete (and is often called the state graph). These constraints imply the possibility of associating discrete, possibly branching timelines to any evolution of the system.

DISCLAIMER: I develop this toolkit as a support for my research on discrete dynamical systems. The primary objective for this framework is to fit my approach to these systems. Essentially, this framework should fit to the "shape of my mind", which is not necessarily the same as yours.

Currently, the toolkit includes the following files:

  • generic.rkt: The generic interface for a discrete dynamical system, with functions for constructing state graphs.

  • utils.rkt: Misc utility functions.

  • networks.rkt: Implements network-based models, which generalise Boolean networks, threshold Boolean automata networks, multivalued networks, etc.

  • rs.rkt: Implements reaction systems, a variant of set rewriting.

The toolkit is designed with Emacs Org-mode interoperability in mind. The file example/example.org explains the features available for interaction with Org-mode.

Roadmap

Here is my current roadmap for this toolkit, in order. The first element is what I am currently working on. The degree of certainty that I work on the subsequent items decreases with their position in the list.

TODO Convert dds to Typed Racket

Rewriting dds with Typed Racket will be a major refactoring, consisting in the following 3 phases which will happen more or less in parallel:

  • define types, add type signatures, add types for functions I import from graph;

  • transfer the comments from the source files to Scribble documentation;

  • redefine the generic interface for dynamics, which is currently in generics.

I plan to implement the new dynamics interface as a classes, since Typed Racket can now type classes. I didn't really like generics: they are quite cumbersome, and I think I can do more with classes.

People on Racket Users suggested using structures with fields containing functions, but it does not seem to get me to my goal of having type-level methods/functions.

The order in which I will convert the modules:

  1. utils

  2. functions

  3. dynamics (currently generics)

  4. networks

  5. rs

This is how I will convert a module A:

  1. Create a copy A-untyped.rkt.

  2. Empty A.rkt.

  3. Transfer the definitions from A-untyped.rkt to A.rkt one by one, adding the necessary types, signatures, and typed imports as I go.

  4. When done, remove A-untyped.rkt.

TODO Implement a shorter syntax for defining Boolean functions

Right now, this is how one defines the Boolean function:

(define (update-go st)
(auto-hash-ref/:
st
(or (and (not :Go) :new-x) (and :Go :old-x))))

It would be nice and probably not too difficult to implement a macro allowing for a syntax like the following one:

(define-pbf my-pbf (or (and (not :Go) :new-x) (and :Go :old-x)))

TODO Implement monotone?

monotone? would verify whether a given Boolean function is monotone according to the definition in the book Boolean Functions: Theory, Algorithms, and Applications by Crama and Hammer.

TODO Submit update-graph to stchang

TODO Split networks into general networks and threshold Boolean networks

TODO Implement the BN → RS conversion

TODO Implement the minimisation of TBF/SBF

TODO Contribute to Racket

  • Make sequence-filter allow multivalued sequences, provided the arity of the predicate is consistent with the arity of the sequence.

  • Add a sequence->hash function that accepts a multivalued sequence of keys and values (exactly like what in-hash produces) and copies them into a hash table.

TODO Test network inference with Racklog