[[Documentation]]
#author("2017-03-02T14:03:59+09:00","default:LMNtal","LMNtal")
//[[Documentation]]

*System Overview
*LaViT: LMNtal Visual Tools [#ed6fa884]

The LMNtal compiler (''lmnc'') first compiles LMNtal source files into
intermediate code.  The intermediate code is then translated into Java programs,
which is in turn compiled into Java bytecode and packaged into a
.jar (Java archive) file.
The created .jar file can be executed using the ''lmnr'' command.
The LaViT IDE should be quite easy to use.  

Alternatively, you can use the ''lmntal'' command to compile LMNtal
programs into intermediate code and execute it
interpretively (rather than translating them into Java).
>>&ref(./editor1.png,60%,around);

When invoked without a source filename, both ''lmnc'' and ''lmntal'' will
enter the read-eval-print loop (REPL) mode in which expressions
are executed interpretively.
The upper-left pane is for
editing programs, while the upper-right pane shows system output.

The system comes with a library API.
In addition, you can define your own libraries to be
used with your programs.
See '''How to create libraries''' (below) for details about libraries.
To run your program, use one of the buttons on the lower-left pane:

LMNtal programs transtaled into Java bytecode run an order of
magnitude faster than the interpreted intermediate code.
:''Compile'':|  Invoke the LMNtal compiler to generate intermediate code.
:''UNYO(2G)'', ''UNYO(3G)'':|  Invoke the 3rd-generation UNYO-UNYO visualizer.  (UNYO-UNYO internally uses the Java runtime.)
:''SLIM'':|  Run the program (LMNtal source or intermediate code) using the SLIM runtime.
:''StateViewer'':|  Visualize the state-space of the program.  StateViewer internally runs SLIM with the --nd (nondeterministic execution) option.

*How to Use
To model-check your program, click the ''LTL model check'' tab of the upper-right pane,

// ('''Note to Cygwin users''': When you run LMNtal (version 0.80 or earlier) on // Cygwin, please use ''lmnc_cyg'', ''lmnr_cyg'', and ''lmntal_cyg''
// instead of ''lmnc'', ''lmnr'', and ''lmntal''.  The ''_cyg'' suffix is not // // necessary for version 0.81 and up.)
>>&ref(./editor2.png,70%,around);

**Using shellscripts (Windows 2000/XP, Cygwin and UNIX/Linux)
and proceed as follows:

On Windows 2000/XP, Cygwin and UNIX/Linux, shellscripts in
the ''bin'' directory facilitate compilation and execution.
- Define propositional symbols that represent properties of states (using the syntax of the left-hand sides of rewrite rules). 
- Specify an LTL formula representing the property you wish to check.
- Press the ''Translate'' button to compile the formula to a Buchi automaton.
- Press the ''slim --ltl'' (or ''slim --ltl-all'' or ''LTL StateViewer'') button to check the specified property.

We suggest you add the path of the ''bin'' directory to the PATH
environment variable of the underlying operating system so that
''lmntal'', ''lmnc'' and ''lmnr'' commands are searched and found
automatically.  Otherwise you must explicitly specify the path of
these commands.
Examples of propositional symbols and LTL formulas can be found by opening the programs under the ''demo/ltl'' directory of the distribution.

***Preparing libraries (Skip this step unless you have your own library)
You can save and load the set of propositional symbols and a LTL formula (that can be numbered from 0 to 9) using the "LTL File" feature on the lower-right. 

Prepare compiled libraries (how to make lirary .jar files will be
explained below) and put them in the ''lib'' directory.
For further details, see [[LaViT>http://www.ueda.info.waseda.ac.jp/lmntal/lavit/]] (in Japanese).

***Compilation
*LMNtal Java [#pbaad941]

 $ lmnc foo.lmn
Compiler options can be specified either before or after the filename.
 $ lmnc -O2 foo.lmn
 $ lmnc foo.lmn -d
The following commands execute the intermediate code intermediately rather
than creating a .jar file.
 $ lmntal foo.lmn
 $ lmnc foo.lmn --interpret
The old page describing the use of LMNtal Java has been moved.
See [[How to Use LMNtal Java]] for details.

***Execution of the .jar file
 $ lmnr foo.jar
Runtime options must be specified '''after''' the .jar filename.
 (ok) $ lmnr foo.jar -g
 (no) $ lmnr -t foo.jar
***Interactive execution (Read-Eval-Print loop)
 $ lmntal

The system enters the interactive when a filename is not specified
in the command line.
Enter an LMNtal expression (that can spread over multiple lines)
and hit the return key twice to execute it.
you can also tell the system to start execution with one newline by
giving the ''--immediate'' option.

The following list shows some interactive-mode commands:

 :q                - quit
 :h                - see help
 :trace | :notrace - set trace mode
 :verbose [0-9]    - set verbosity level
 :shuffle [0-3]    - set shuffle level

Here is an example of an interactive mode session:

 % lmntal [PRESS ENTER]
         LMNtal version 0.83.20061129
 
 Type :h to see help.
 Type :q to quit.
 Enter an empty line to run the input.
 
 # A=f(f(f(f(f(A))))), c,c, ( c, X=f(Y) :- X=g(Y) ) [PRESS ENTER]
 [PRESS ENTER]
 f(g(g(f(f(_4)))),_4), @601
 # A=f(f(f(f(f(A))))), c,c, ( c, X=f(Y) :- X=g(Y) ) [PRESS ENTER]
 [PRESS ENTER]
 g(f(f(f(g(_24)))),_24), @604
 # :q [PRESS ENTER]
 %


**Doing manually (Windows 9x etc.)

***Compilation
++When standard or user-defined libraries are used, add their
.jar files into the classpath.
++Compile the source file:
 $ java runtime.FrontEnd foo.lmn
++foo.jar will be created.
***Execution
++Add foo.jar into the classpath.
++When standard or user-defined libraries are used, add their
.jar files into the classpath.
++Invoke the Main class (in foo.jar) as:
 java Main

*Command-line options

There are many options for compilation and execution.
Popular options include:

 -t            - trace mode
 -v[0-9]       - set verbosity level ( -v = -v5 )
 -s[0-3]       - set shuffle level ( -s = -s3 )
 -g            - graphical (visualizer) mode 

To see the list of all available options, do:
  lmntal --help

A Verbosity Level
expresses how verbosely an LMNtal process is displayed.

   0: silence
   1: default
   2: expand link names
   3: shows the contents of rulesets just compiled
   4: expand operators
   5: expand atoms
   6: expand rulesets

A shuffle Level
expresses how randomly the execution goes on.

   0: (default) use an atom stack for each membrane
      (atoms are selected in a LIFO manner)
   1: atoms are selected in a system-defined order
      (which is not random or LIFO)
   2: select atoms and membranes randomly from a membrane
   3: select atoms, membranes and rules randomly from a membrane

The graphical Mode (experimental) visualizes program execution.
A graphical window will be displayed that visualizes the
evolution of hierarchical graph structure.
Computation proceeds step by step by pressing the space bar or
clicking on the 'Go ahead' button.
Atoms can be dragged to arbitrary positions so that the graph
may look better.
To terminate the execution, close the window manually.


*How to create libraries

A library is a program that is prepared (compiled) separately
and added to the classpath.  A library can be used also
with a program running under the --interpret option.

By using shellscripts in the ''bin'' directory, you can invoke LMNtal
after adding all .jar files located in the ''lib'' directory to the
classpath.

You can also use the source code of the library by giving
the ''--use-source-library'' option, in which case the .lmn files
in the ''lib/src'' directory will be read and compiled on demand.

To create your own program library, compile the program
with the ''--library'' option:

 lmnc --library libhoge.lmn
 java runtime.FrontEnd --library libhoge.lmn  (Windows 9x)

Then, move the .jar file to the ''$LMNTAL_HOME/lib'' directory.

*Classes built by the translator

-General rules 
--One Java class will be created for each ruleset
(= a set of rules located in the same 'place' of the membrane
structure in the source program).
--The class name will be ''Ruleset''('''rule_set_ID''')'.
--When the compiled program contains a module definition,
a class ''Module_''('''module_name''')' will be created in the
''translated'' package. 
---The class has a static method ''getRulesets()'' that
returns a list of rulesets contained in that module.

-For non-libraries:
--The ruleset classes belong to the package ''translated''.
--The class ''Main'' will be generated in the default package.

-For libraries:
--The ruleset classes belong to the package
''translated.module_''('''library_name''').

*System rulesets

-A '''system ruleset''' is a set of global rules, namely
rules applicable to every place in the membrane structure.
For instance, built-in arithmetics (that evaluates
x=1+2*3 to x=7, for example) is implemented as
system rulesets.

-A programmer can define his/her own system ruleset by
defining the ''system_ruleset'' module.

//-There are three kinds of system rulesets:
// ++Built-in system rulesets that cannot be modified by users
// ---Proxies for trans-membrane links fall into this category.
//---Currently, they are processed in InterpretedRuleset
//even when the translator is used.
//++Built-in system rulesets that are described in LMNtal and
//can be modified
//---Arithmetics falls in this category, but the current implementation
//handles arithetics much like i.
//++LMNtal ?v???O??????????W???[???????????????isystem_ruleset?j

//i. ? ii. ??ATranslator ?????R???p?C????? runtiem.GlobalSystemRuleset
//?N???X????B
//??? iii. ??Aruntime.SystemRulesets ?N???X?????????B


*Bugs

-A large LMNtal program may create a Java class definition
that is too large to be compiled by your Java compiler.

-The ''aggregate'' construct have not yet been implemented.  However,
you can use the standard library module ''nlmem'' to copy or kill
cells with an indefinite number of free links.

-Shuffle levels 0-2 can be specified as a runtime option, while 
shuffle level 3 must be specified also at compile time.


Front page List of pages Search Recent changes Backup   Help   RSS of recent changes