Bluish Coder: mozartoz

Relational Programming in Mozart/Oz

2017-03-20T23:00:00+13:00

A video I watched recently on logic programming, A Vision for Relational Programming in miniKanren, by William Byrd gives some interesting examples of relational programming using miniKanren.

miniKanren is an embedded constraint logic programming language designed for writing programs as relations, rather than as functions or procedures. Unlike a function, a miniKanren relation makes no distinction between its inputs and outputs, leading to a variety of fascinating behaviors. For example, an interpreter written as a relation can also perform code synthesis, symbolic execution, and many other tasks.

The video demonstrates how a relational interpreter can be used not just to evaluate expressions but to also generate valid expressions given a result. Other examples of relational programming would be the Prolog examples in my Shen Prolog post where relational functions like member can be used to enumerate all members of a list, as well as the traditional finding a member in a list.

I like to use the Mozart Programming System for exploring logic programming and this post goes through converting some examples in Mozart/Oz. Mozart is an implementation of the Oz programming language. The book "Concepts, Techniques, and Models of Computer Programming" is a good textbook for learning the different programming models that Mozart enables, including the relational model. For the examples here I'm using Mozart 1.3.x. It's an old language and implementation but I like to experiment with languages that are a bit different to mainstream languages.

The Prolog examples following can be tested in the online SWI Prolog implementation, Swish.

Basic example

The following function in Prolog has multiple values that be used as an argument:

foo(one).
foo(two).
foo(three).

Passing either one, two or three succeeds:

foo(one).
true

foo(two).
true

foo(four).
false

Using backtracking it's possible to enumerate all valid arguments:

foo(X).
X = one
X = two
X = three

The function findall can be used to return all values in a list:

findall(X, foo(X), Y).
Y = [one, two, three]

Backtracking in Mozart/Oz is not the default. Mozart provides the choice statement to enable backtracking. A choice statement contains a sequence of clauses separated by [] where a 'choice point' is created for each group of clauses. Each clause is tried in turn - if a particular clause fails then execution backtracks to a previous choice point and is resumed until one succeeds or all fails. The equivalent implementation of foo in Mozart is:

fun {Foo}
   choice
      one
   []
      two
   []
      three
   end
end

Prolog uses an automatic depth first search to find solutions. Mozart doesn't do automatic search - programs involving choice points must be run in a search engine that can implement any form of search required. A default search engine is provided that does depth first search. Here we create a search object and enumerate all the valid results manually:

Y = {New Search.object script(Foo)}
{Browse {Y next($)}
[one]

{Browse {Y next($)}
[two]

{Browse {Y next($)}
[three]

{Browse {Y next($)}
nil

The Mozart syntax can look a little strange at first but it's not too difficult to understand once it's learnt. New instantiates an object. Search.object is the class of the object being created. script(Foo) is a record that is being passed to the constructor of Search.object. The Foo is the function we created previously. The remaining statements call the next method on the object. next takes as an argument a variable that receives the result of the call. The use of $ tells Mozart to pass a temporary variable to receive the result, and return that result as the result of the call. This result is passed to Browse which displays the result in the GUI browser. Results are returned in single element lists and when there are no more results, nil is returned.

There is a library function to return all possible solutions in a list, Search.all:

{Browse {Search.all Foo 1 _ $}}
[one two three]

The ability to interactively drive the search enables writing programs that control the search process. The Explorer is a Mozart tool that uses this ability to show an interactive graph of the search space of a program. It can be run to show a graph of all solutions in Foo with:

{Explorer.all Foo}

Membership testing

In Prolog a function to test membership of a list can be written as:

mem(X, [X|_]).
mem(X, [_|Y]) :- mem(X, Y).

This states that X is a member of the list if X is the head of the list (the first element), or if it is a member of the tail of the list.

mem(2, [1,2,3]).
true.

Thanks to Prolog's backtracking you can also use this function to enumerate all values in the list:

mem(X, [1,2,3]).
1
2
3

In Swish you need to click 'Next' to get each result. You can return all results as a list with findall:

findall(X, mem(X, [1,2,3]), Y).
Y = [1, 2, 3].

This is what the non-backtrackable member function looks like in Mozart:

fun {Mem X Ys}
   case Ys
   of nil then false
   [] Y|Yr then X==Y orelse {Mem X Yr}
   end
end

{Browse {Mem 1 [1 2 3]}}
true

A backtrackable version of this code uses choice instead of case to create choice points in each clause:

proc {Mem X Ys}
   choice
      Ys = X|_
   []
      Yr
   in
      Ys = _|Yr
      {Mem X Yr}
   end
end

Here proc is used instead of fun. A procedure doesn't return a value. It is expected to bind values to arguments to return a result. In this case either X or Ys will be bound depending on what is passed as an argument. Given the call Mem 1 [1 2 3] then the first clause of choice succeeds - the head of the list is equal to X. With the call Mem X [1 2 3] then X will be successively bound to each element of the list depending on what order the search engine used to evaluate it uses. Mem 1 Y will enumerate all possible lists containing 1:

{Browse {Search.all proc {$ L} {Mem 1 [1 2 3]} end 1 _ $}}
[_]

{Browse {Search.all proc {$ L} {Mem L [1 2 3]} end 1 _ $}}
[1 2 3]

Y={New Search.object script(proc {$ L} {Mem 1 L} end)}
{Browse {Y next($)}}
[1|_]

{Browse {Y next($)}}
[_|1|_]

{Browse {Y next($)}}
[_|_|1|_]

The difference here compared to our search over Foo is that an anonymous procedure is passed to the search engine. Foo was aleady a single argument procedure so it didn't require a wrapper. The anonymous procedure takes a single argument which is expected to be bound to the result of a single iteration. In the first example no result is bound, just the fact that the Mem call succeeds is enough. In the second, L is bound to the first argument to Mem resulting in a list of all valid first arguments. In the third, L is bound to the second argument to Mem resulting in a list of all valid lists that contain the element 1. This is infinite so we only iterate the first few solutions.

Syntax checker

The miniKanren video referenced earlier, A Vision for Relational Programming in miniKanren, has an example of a simple language syntax checker implemented in the relational style. The equivalent Mozart implementation is:

proc {LCSyn Term}
   choice
      {IsAtom Term true}
   []
      X T
   in
      Term = lambda(X T)
      {IsAtom X true}
      {LCSyn T}
   []
      E1 E2
   in
      Term = [E1 E2]
      {LCSyn E1}
      {LCSyn E2}
   end
end

A Term is either an atom, a lambda record containing an argument and body, or application of two expressions (here represented as a list). A Term can be tested to see if it is valid with:

{Browse {Search.one.depth
         proc {$ L}
            {LCSyn lambda(foo bar)}
         end
         1 _ $}}

A result of [_] indicates that it succeded (nil would be a failure). Thanks to the magic of relational programming it's possible to enumerate all valid terms:

Y={New Search.object script(LCSyn)}
{Browse {Y next($)}}
[lambda(_ _)]

{Browse {Y next($)}}
[[_ _]]

{Browse {Y next($)}}
[[lambda(_ _) _]]

{Browse {Y next($)}}
[[[_ _] _]]

Reversible Factorial

As a final example, the following program implements a factorial function that can compute the factorial of a number, or the number given its factorial:

proc {Fact ?N ?F}
   proc {Fact1 ?N ?F}
      choice
         N = 0
         F = 1
      []
         N1 F1
      in
         N1::0#FD.sup
         F1::0#FD.sup
         N >: 0
         N1 =: N - 1
         F =: N * F1
         {Fact1 N1 F1}
      end
   end
in
   N::0#FD.sup
   F::0#FD.sup      
   {Fact1 N F}
   {FD.distribute naive [N F]}
end

% Factorial of 5
{Browse {Search.all proc {$ L} {Fact 5 L} end 1 _ $}}
[120]

% What factorial gives the answer 24
{Browse {Search.all proc {$ L} {Fact L 24} end 1 _ $}}
[4]

This uses a few more Mozart features but is essentially a search through the choice points in a choice statement. In this case it also uses Finate Domain Constraints. This allows telling Mozart what the range of a particular integer value can be, provides constraints upon that value and the search process will attempt to find a solution that results in the integer containing a single value. The syntax X::0#5 constrains the variable X to be from zero to five. FD.sup is a constant for an implementation defined maximum upper bound. Operators ending in : impose constraints on values that can be backtracked during search. There's a limitation to this approach in that the finite domain constraint has an implementation defined maximum upper value and the search will fail if it hits this value which unfortunately limits the practicality of a reverse factorial.

Mozart/Oz summary

Mozart/Oz has a lot of other interesting functionality. Distributed objects, GUI programming, Concurrency, amongst others. It's a fun tool to experiment with and Concepts, Techniques, and Models of Computer Programming is an excellent read.

Unfortunately development of Mozart has slowed from its heyday. A reimplementation of Mozart, called Mozart 2 is being worked on that uses LLVM for the code generator and replaces the internal constraint programming system with the Gecode toolkit. Development seems to have stalled recently and it lacks many of the features that already exist in older Mozart versions. Hopefully it'll pick up steam again.

For this reason I continue to use Mozart 1.3.x. There is a 1.4.x version but it has some issues that make me avoid using it. The distributed layer was replaced with an implementation written in C++ which has some bugs that I've been unable to work around in projects where I used it. The distribution panel is broken due to the hooks it requires not being implemented by the new C++ layer. At some point Mozart 2 may be complete enough for me to move to that version. I make the occasional fixes to 1.3.x and 1.4.x to keep it building and running on Linux.

Even though Mozart seems to be in a holding pattern it's a great for exploring ideas and the list of papers is a good resource for learning about distributed programming, constraints and concurrency. Some interesting projects implemented in Mozart include:

Beernet, a P2P network (source).
Ebl/Tk (PDF), a GUI library where widgets can be migrated across devices (source).
Roads, a web application framework (source).
Transdraw, a distributed collaborative graphical editor (source).
Strasheela, a constraint based music system which also has a good Oz tutorial.

Building Mozart/Oz on Windows

2011-05-11T20:00:00+12:00

The Mozart Programming System is an implementation of the Oz programming language. It's the language used in the book Concepts, Techniques, and Models of Computer Programming by Peter Van Roy and Seif Haridi. From the Mozart website:

Mozart is based on the Oz language, which supports declarative programming, object-oriented programming, constraint programming, and concurrency as part of a coherent whole. For distribution, Mozart provides a true network transparent implementation with support for network awareness, openness, and fault tolerance. Mozart supports multi-core programming with its network transparent distribution and is an ideal platform for both general-purpose distributed applications as well as for hard problems requiring sophisticated optimization and inferencing abilities.

The last release of Mozart was a couple of years ago and the steps to build on Windows no longer seem to work. It required Cygwin to build but used the MingW compiler to get a native Windows build.

Mozart/Oz has recently seen a bit of a life with activity in the mailing lists and a move to github for source control and issue tracking. I was working on a project that needed Windows and Linux support so thought I'd have a try at converting Mozart to compile using MingW on Windows.

I've got a basic build working and have patches that I hope will eventually be merged. In the meantime I thought I'd post about how to build using MingW with my patches. The following steps will build Mozart, the standard library, Emacs (used as the IDE) and Tcl/Tk (for GUI).

Download and install mingw-get-inst. Install the 'MSYS Basic System' and the 'C++ Compiler'.

From the 'MingW Shell', run the following commands to install the required support packages:

 $ mingw-get install mingw32-libgmp
 $ mingw-get install mingw32-gmp
 $ mingw-get install mingw32-libz
 $ mingw-get install msys-libgdbm
 $ mingw-get install msys-libregex
 $ mingw-get install mingw32-autoconf2.1
 $ mingw-get install mingw32-autoconf
 $ mingw-get install msys-flex
 $ mingw-get install msys-bison
 $ mingw-get install mingw32-gcc-g++
 $ mingw-get install msys-wget

Download and install the msysgit package. I installed it in C:/git. It's best to install it in a directory that doesn't have spaces in the name.
Make a directory to store the resulting 'Mozart/Oz' binaries. I used /p to keep my command lines short but you could also use /mingw to install alongside the existing MingW programs:
```
 $ mkdir /p
```

Download and build Tcl/Tk 8.5 from source, configured to install in the directory above:

 $ wget http://prdownloads.sourceforge.net/tcl/tcl8.5.9-src.tar.gz
 $ wget http://prdownloads.sourceforge.net/tcl/tk8.5.9-src.tar.gz
 $ tar xvf tcl8.5.9-src.tar.gz
 $ tar xvf tk8.5.9-src.tar.gz
 $ cd tcl8.5.9
 tcl8.5.9 $ ./win/configure --prefix=/p
 tcl8.5.9 $ make && make install
 tcl8.5.9 $ cd ../tk8.5.9
 tk8.5.9 $ ./win/configure --prefix=/p --with-tcl=`pwd`/../tcl8.5.9
 tk8.5.8 $ make && make install

Download and build emacs from source:

 $ wget http://ftp.gnu.org/gnu/emacs/emacs-23.3.tar.gz
 $ tar xvf emacs-23.3.tar.gz
 $ cd emacs-23.3
 emacs-23.3 $ cd nt
 emacs-23.3/nt $ cmd /c "configure --prefix=/p --without-xpm \
                  --without-png --without-jpeg --without-tiff --without-gif"
 emacs-23.3/nt $ make && make install

Build my win32_build branch of Mozart. Note that I add the directory where I installed Git into the path. I also add the 'bin' directory of where I set Mozart to be installed.

 $ export PATH=$PATH:/c/git/bin:/p/bin
 $ git clone git://github.com/doublec/mozart.git
 $ cd mozart
 mozart $ git checkout -b win32_build origin/win32_build
 mozart $ cd ..
 $ mkdir build
 $ cd build
 build $ windlldir=/p ../mozart/configure --prefix=/p \
          --with-inc-dir=/p/include --with-lib-dir=/p/lib \
          --with-tcl=/p --with-tk=/p --disable-contrib-compat \
          --disable-contrib --enable-modules-static \
          --disable-doc --disable-chm
 build $ make && make install

Build my win32_build branch of the Mozart standard library:

 $ git clone git://github.com/doublec/mozart-stdlib.git
 $ cd mozart-stdlib
 mozart-stdlib $ git checkout -b win32_build origin/win32_build
 mozart-stdlib $ cd ..
 $ mkdir build-stdlib
 $ cd build-stdlib
 build-stdlib $ ../mozart-stdlib/configure --prefix=/p
 build-stdlib $ make && make install

You can now test Mozart by running the comand oz. This should start emacs with a Mozart/Oz system running. You can evaluate an example by entering {Browse 1+1} into the topmost emacs pane and evaluating with Ctrl+. Ctrl+l. You'll need to set the OZEMACS environment variable to point to the location of emacs:
```
 $ export OZEMACS=/p/bin/emacs.exe
 $ oz
```

That's a large number of steps but it gives a complete Mozart/Oz environment. From there you can work through the tutorial. There's work to be done to make it easier and get more testing. One contributor is looking at creating a Visual Studio project to do the builds as well as to improve on the basic MingW support I've got working, so there's hope for less steps in the future.

The Mozart/Oz system is interesting and there's some neat projects written in it. A short list of some of them:

BeerNet, a P2P network.
TransDraw, a distributed shared drawing program. I run a live transdraw instance which you can connect too. Instructions here.
Roads, a web application framework.
EBL/Tk, an UI library that can do migration of user interface elements across the network.