*LMNtal, a unifying language and tool
#author("2017-03-02T13:53:03+09:00","default:LMNtal","LMNtal")
*LMNtal, a unifying language and model checking tools [#nb83a963]

LMNtal (pronounced "elemental") is a programming and modeling language based on '''hierarchical graph rewriting'''.  It was designed to be a substrate language of diverse computational models, especially those addressing concurrency, mobility and multiset rewriting, including (Colored) Petri Nets, Interaction Nets, the Pi-Calculus, Chemical Abstract Machines, Constraint Handling Rules, and Bigraphs.  It features

-point-to-point ''links'' to represent connectivity,
-''membranes'' to represent hierarchy,
-point-to-point '''links''' to represent connectivity,
-'''membranes''' to represent hierarchy and locality, and
// -rule-based multiset rewriting,
// -locality of rewrite rules,
-dynamic migration of processes and rewrite rules, and
// -dynamic migration of processes and rewrite rules, and
-graphical view of programs and computation (see Figure below).
// -uniform treatment of processes and data,
// -and so on.

The language has been fully implemented using Java and C.  Various unique features have been integrated into ''LaViT'' ('''LMNtal Visual Tools'''; formerly called LMNtalEditor), an integrated development environment of LMNtal.  LaViT comes with
Our full-fledged implementation supports ''nondeterministic state-space search'' and ''LTL model checking'' as well as ordinary graph-rewriting execution, making it an expressive verification tool.

- ''nondeterministic state-space search'',
- state-space visualizer,
- ''LTL model checker'' (using LMNtal as the modeling language), and
- graph visualizer.
Various unique features have been integrated into ''LaViT'' ('''LMNtal Visual Tools'''), an integrated development environment of LMNtal, that supports '''graph visualizer''' and '''state-space visualizer''' that turns out to be very useful for '''understanding''' as well as debugging your models and programs.

**Model checking with LaViT
**Programming and modeling with links and membranes [#pa0251c2]

Model checking combined with state-space visualization demonstrates that LaViT is extremely useful for '''understanding''' as well as '''debugging''' your models and programs.  LaViT can be and has been used to run and visualize diverse examples taken from the fields of model checking, concurrency and AI search.
The power of LMNtal comes from two structuring mechanisms,
-links for expressing connectivity and
-membranes for expressing hierarchy.

The figure below (click to enlarge) illustrates how hierarchical graphs allow you to represent various concepts appearing in computer science. 

#ref(diagrams.png,left,12%,around);
// http://www.ueda.info.waseda.ac.jp/lmntal/image/diagrams-low.png

**State-space search and model checking with LMNtal and LaViT [#r9123801]

Our LMNtal implementation supports both ordinary execution
(as a rule-based programming language) and state-space search
(as a language for modeling and verification), and state-space search
can further be combined with LTL model checking.

The LMNtal model checker is unique in three ways: (i) the modeling language itself, (ii) state-space visualization, and (iii) scalable parallel state-space construction.

Firstly, LMNtal allows extremely terse representation of some transition systems.  For example, with only one rewrite rule, the state space of the Tower of Hanoi can be constructed and visualized (click the image to enlarge and view the program).  This conciseness is thanks to the powerful symmetry reduction mechanism inherent in the hierarchical graph representation of states.

#ref(./hanoi5.png,20%,center,around);
Secondly, LaViT's state-space visualizer demonstrates that it is extremely useful for '''understanding''' as well as '''debugging''' your models and programs.  LaViT can be and has been used to run and visualize diverse examples taken from the fields of model checking, concurrency and AI search.
#img(,clear);

Thirdly, LMNtal's rich data structures are efficiently handled by our '''scalable parallel implementation''', which can now handle a state space with more than a billion (10^9) states on shared-memory machines with tens of cores.


// An implementation (a translator into intermediate code and
// a runtime system) running on a Java platform is available.
// It features 

//-arithmetics,
//-modules,
//-nondeterministic execution (exhaustive search),
//-foreign-language interface to Java,
//-visualizer,
//-read-eval-print loop,
//-optimizer,
//-redex/rule selection strategies, and
//-libraries.

LMNtal allows extremely terse representation of some transition systems.  For example, with only one rule, the state space of the Tower of Hanoi can be explored and visualized.

#ref(hanoi5.png,center,40%,around);
**Developers [#a4d9020a]

**Programming and modeling with links and membranes

The power of LMNtal comes from two structuring mechanisms, links and membranes.  The figure below illustrates how hierarchical graphs allow you to represent various concepts appearing in computer science. 

#ref(diagrams.png,center,20%,around);
// http://www.ueda.info.waseda.ac.jp/lmntal/image/diagrams-low.png

The language and the implementation has been developed since 2002 by
the LMNtal team, Dept. of Computer Science and Engineering, Waseda University.

//**Sample Input 1
//    a,a,a,a,a,a, (a,a :- {a}), ({$p,a},{$q} :- $p,$q) 
//
//**Sample Input 2
//[[Download]] (append.lmn)

mailto: lmntal _AtSign_ ueda.info.waseda.ac.jp

//--started to copy contents -- [[nakajima]] &new{2004-01-30 (Fri) 22:13:40};
//--edited the menubar to hide titles written in EUC-JP -- [[nakajima]] &new{2004-02-01 (Sun) 21:33:05};
//--added edit auth -- [[nakajima]] &new{2004-02-03 (Tue) 17:47:44};
//--new skin installed -- [[nakajima]] &new{2004-02-13 (Fri) 17:19:23};
//#comment


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