I started to work on this, here is what I am doing right now and then what I need further.

**Principle.** I am using the g-patterns formalism to separate the reduction of molecules from the visual representation of them. For those who want to know more about here is the definition of g-patterns and here is the definition of moves in terms of g-patterns.

**Reduction strategy.** For the moment I am using a sequential strategy of reduction, with priority choices, like this:

At each reduction step do the following:

- if no LEFT patterns of the moves BETA, DIST, FAN-IN and LOC-PR are present in the g-pattern, then stop, else
- identify the LEFT patterns of the moves BETA, DIST, FAN-IN and LOC-PR. If there is a graphical element which is part of two distinct patterns then apply a PRIORITY CHOICE
- apply the moves from LEFT to RIGHT
- apply the COMB moves until no Arrow element

can be eliminated - repeat.

There is a subtlety concerning the use of CO-COMM and CO-ASSOC moves, related to the fact that I don’t want to use them directly, and related to the goal which I have, which may be one of those:

- use chemlambda regardless of its relation to lambda calculus (big goal). In this case there is no separation of reduction into self-multiplication and pure reduction. This strategy gets out quick, but in interesting ways, from lambda calculus, even if we start from a molecule which represents a lambda term.
- use chemlambda for illustrating lambda calculus (small goal). In this case the reduction strategy involves a move called SHUFFLE (which is equivalent with CO-COMM and CO-ASSOC) and a separation of the self-multiplication from pure reduction.

**Where I am now.** I wrote some shell scripts, using awk and perl, to do the first strategy and I know what to do to have the second strategy as well.

Mind that I learn as I do, so probably the main shell script should be named frankenstein.sh.

**What I need next. ** The format of g-patterns can be easily turned into a format (I lean towards json) which can be then visualized as a force directed d3 graph. I need help here, I know there are lots of things already done, the main idea is that it should be something which doesn’t use java, has to be free, eventually has to need only the program I prepare (which will be freely available) and a browser.

**What I need after.** Several things:

- to be able to build a molecule in the window I see the graphs and to be able to convert back, to a g-pattern format. Basically this means that I need a way to add nodes which have ports, colors (red or green), such that if the node is 3valent then the cyclical order of ports is fixed. Once added, there should be a json (say) file where the graph is saved, and then I can make a script to transform it into a g-pattern format.
- a lambda calculus parser, which takes a lambda term (input from the user) and produces the g-pattern. See this post for the description of an algorithm which does this, starting from a lambda term with the property that if x is a bound variable then it appears under the scope of only one abstraction and moreover it does not appear as a free variable. I can write a script which does that, but I could use something which transforms a lambda term into one which can be used in the algorithm. By extension, why not a lisp to lambda calculus convertor, which can the be plugged into the pipe of the GUI?

That’s it for the moment, I APPRECIATE USEFUL HELP, thank you.

______________________________________________________________