Hets is the main analysis tool for the specification language heterogeneous CASL. Heterogeneous CASL (HetCASL, see http://www.informatik.uni-bremen.de/agbkb/forschung/formal_methods/CoFI/HetCASL/index_e.htm) combines the specification language CASL with CASL extensions and sublanguages, as well as completely different logics and even programming languages such as Haskell, including its module system. Hets provides parsing, static analysis and proof management (via development graphs), as well as many other functionalities. Hets is written in Haskell (see http://www.haskell.org and http://trac.informatik.uni-bremen.de:8080/hets/wiki/HetsForDevelopers)

The general background of Hets is explained in /Heterogeneous specification and the heterogeneous tool set/ (http://www.informatik.uni-bremen.de/~till/papers/habil.ps). A short introduction is given in http://www.informatik.uni-bremen.de/~till/papers/hets-tacas.pdf.

The Hets modules are grouped using hierarchical modules (where modules can be grouped into folders); we here only discuss the top view on this hierarchy. For a more details, look at the descriptions of the folders or the individual modules.

The folder Logic contains the infrastructure needed for presenting a logic to Hets. This is complemented by folders working at the heterogeneous level --- the code in modules in these folders is parameterized over an arbitrary but fixed logic graph. Existential types are used for implementing the heterogeneity, see http://haskell.org/haskellwiki/Existential_type. The folder Syntax (see Syntax.ADoc) provides abstract syntax and parsing of heterogeneous structured specifications. Static is for the static analysis, based on the verification static semantics for Heterogeneous CASL. Static.DevGraph contains the data structures for heterogeneous development graphs, including proof management. Finally, the folder Proofs contains an implementation of the proof calculus for heterogeneous development graphs.

The folders CASL, CoCASL, HasCASL, Haskell, CspCASL, Modal, Isabelle contain different instances of the type class Logic of the module Logic.Logic. These instances always are contained in a module named Logic_xxx, where xxx is the name of the language at hand. Since the integration of a new logic into Hets requires writing a new instantiation of the type class Logic, it is advisable to consult the module Logic_xxx (and the modules imported there) for some logic that is in some sense similar to the new logic to be integrated. In particular, we have implemented the CASL logic in such a way that much of the folder CASL can be re-used for CASL extensions as well; this is achieved via holes (realized via polymorphic variables) in the types for signatures, morphisms, abstract syntax etc. This eases integration of CASL extensions and keeps the effort quite moderate.

The folder Comorphisms contains various comorphisms and other translations that constitute the logic graph. Note that these modules can be compiled independently of the logic independent heterogeneous modules listed above. The module Comorphisms.LogicList assembles all the logics into one (heterogeneous) list, while Comorphisms.LogicGraph builds up the logic graph, i.e. it assembles all the (co)morphisms among the logics, and also specifies which ones are standard inclusions. This module also provides a partial union for logics, which is crucial for the static analysis of unions of specifications (which may occur explicitly or implicitly).

Last but not least, there are general purpose folders. The most important one is the folder Common. It contains general purpose libraries, e.g. for relations, and for parsing and pretty printing. Common.Result provides a monad for error handling and error messages that is used at many places throughout Hets (see http://www.haskell.org/all_about_monads/ for an introduction to monads).

The folder ATC is for conversion from and to shared ATerms. The utils folder contains tools like DriFT and InlineAxioms, the latter can be used to write the axioms for theoroidal comorphisms in a concise way, namely in the input syntax of the respective target logic (the identifiers will turn into Haskell variables and can hence be used for easily producing instances of axiom schemes).

The command line interface is contained in Driver, the graphical interface in GUI. The latter is based on the UniForM Workbench that provides an event system and encapsulations of TclTk http://www.informatik.uni-bremen.de/htk/ and uDraw(Graph) http://www.informatik.uni-bremen.de/uDrawGraph/en/index.html.

Hets is also based on the following third-party libraries:

• HXT for XML parsing and printing, see http://www.haskell.org/haskellwiki/HXT, http://hackage.haskell.org/package/hxt-filter and OMDoc.OMDocXml for a sample use. We would like to switch to the xml light package below.
• The combinator parser library Parsec, see http://www.haskell.org/haskellwiki/Parsec, http://hackage.haskell.org/package/parsec and Propositional.Parse_AS_Basic for a sample use
• finite sets and maps, see http://hackage.haskell.org/package/containers
• finite graphs from the functional graph library (fgl), see http://web.engr.oregonstate.edu/~erwig/fgl/haskell/ and http://hackage.haskell.org/package/fgl
• the xml light package, see http://hackage.haskell.org/package/xml
• Haskeline for the command line interface, see http://trac.haskell.org/haskeline and http://hackage.haskell.org/package/haskeline
• programatica for Haskell as a logic, see http://programatica.cs.pdx.edu/

Visit Driver.Version for the date of this documentation.