120 lines
5.4 KiB
Org Mode
120 lines
5.4 KiB
Org Mode
* dds: A Home-made Toolkit for Discrete Dynamical Systems in Racket
|
||
This is a toolkit for playing with various discrete dynamical systems
|
||
in [[https://racket-lang.org/][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:
|
||
|
||
- [[file:generic.rkt][generic.rkt]]: The generic interface for a discrete dynamical
|
||
system, with functions for constructing state graphs.
|
||
- [[file:utils.rkt][utils.rkt]]: Misc utilities.
|
||
- [[file:functions.rkt][functions.rkt]]: Definitions for working with functions: tabulating,
|
||
constructing from tables, generating random functions, etc.
|
||
- [[file:networks.rkt][networks.rkt]]: Implements network-based models, which generalise
|
||
Boolean networks, threshold Boolean automata networks, multivalued
|
||
networks, etc.
|
||
- [[file:rs.rkt][rs.rkt]]: Implements reaction systems, a variant of set rewriting.
|
||
|
||
The toolkit is designed with Emacs [[https://orgmode.org/][Org-mode]] interoperability in mind.
|
||
The file [[file:example/example.org][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 as a structure, from which
|
||
all the concrete dynamics of the objects will inherit. This will
|
||
hopefully work like interface inheritance. The current plan is to
|
||
start converting =networks= to Typed Racket, then starting the new
|
||
module =dynamics= to fill in the blanks progressively by moving
|
||
over bits of code from =generics=. The goal is to have an empty
|
||
=generics= module at the end.
|
||
|
||
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. =networks= and =dynamics= (currently =generics=) at the same
|
||
time,
|
||
4. =networks=,
|
||
5. =rs=.
|
||
|
||
I will convert the modules one by one by first creating a typed
|
||
section (a submodule) and re-exporting its functions together with
|
||
the untyped functions. I will then move the functions one by one
|
||
from the untyped section to the typed section. When the untyped
|
||
section is empty, I will convert the language of the entire module
|
||
to Typed Racket and remove the submodule.
|
||
|
||
*** TODO Remove the artifacts of conversion to Typed Racket
|
||
Since I am converting =dds= to Typed Racket gradually, I need to
|
||
leave a couple artifacts to ensure that older code compiles with
|
||
newer code. These artifacts are marked with the keywords =TODO:=
|
||
in the source.
|
||
|
||
*** TODO Think about splitting the library into lib and doc
|
||
|
||
*** TODO Implement a shorter syntax for defining Boolean functions
|
||
Right now, this is how one defines the Boolean function:
|
||
|
||
#+BEGIN_SRC racket :results output silent
|
||
(define (update-go st)
|
||
(auto-hash-ref/:
|
||
st
|
||
(or (and (not :Go) :new-x) (and :Go :old-x))))
|
||
#+END_SRC
|
||
|
||
It would be nice and probably not too difficult to implement
|
||
a macro allowing for a syntax like the following one:
|
||
#+BEGIN_SRC racket :results output silent
|
||
(define-pbf my-pbf (or (and (not :Go) :new-x) (and :Go :old-x)))
|
||
#+END_SRC
|
||
|
||
*** 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 \to 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 [[https://docs.racket-lang.org/racklog/index.html][Racklog]]
|