Subprojects on Math Engine

TP abbreviates 'Theorem Proving', TP-PL abbreviates 'TP-based programming language' and LIP abbreviates 'Lucas Interpreter'.

These subprojects improve and extend the ISAC math-engine. The projects require motivation to learn functional programming (a motivation which might be increased by further good reasons )

Improve the usability of ISAC's TP-PL
Programmers of ISAC's present prototype TP-PL have a hard life: simple program errors cause strange messages from the system and surprising exceptions -- the structure of exceptions and messages still focuses internals of LIP.

Remedy these shortcomings will review the whole architecture of ISAC's prototype LIP, will improve error messages and will establish levels of exception handling clearly separating internals of LIP from issues concerning a programmer.

Efficient programming for engineering applications requires these and other improvements !

Improve automated TP-services for LIP
ISAC's TP-LP has a powerful mechanism for sub-problems: the LIP instantiates a specification-pattern to a specification and evaluates the precondition before the respective program is called.

The same should happen with the postcondition upon completion of a sub-problem. However, this is not yet done in the present prototype, for two reasons:
 * 1) it is unclear how to formulate a general pattern for postconditions, how to instantiate the pattern and finally how to evaluate the instantiation; see an example for optimisation problems.
 * 2) apparently, proving postconditions requires handling of logical context which is more careful and more complete than in the present prototype.

Several challenges involved !

Extend ISAC's experimental TP-PL
ISAC's TP-based programming language has a sub-program mechanism for modularisation and several statetments for flow control, for instance, Repeat, Try, Or, all closely related to Isabelle's tacticals. The set of statements shall be extended, in particular with Parallel. Modularisation shall be extended by (recursive!) functions.

A concrete goal of this task is to make ISAC's TP_PL ready for implementation of functions in Symbolic Computation, for instance cancellation of multivariate polynimials -- this would make sophisticated Symbolic Computation available for single-stepping, i.e. establish a new level of transparent systems.

Implement debugging facilities for the TP-LP
The parse-tree of ISAC's prototype TP-LP is an Isabelle term, where the LIP proceeds from sub-term to sub-term.

The step-wise progress of interpretation by LIP shall be visualized by general operations on sub-terms in Isabelle/jEdit. The visualisation shall be combined with access to values of variables and content of the logical context.

Bring ISAC's rewriter closer to Isabelle's rewriter
ISAC's rewriter works on both, on the object language and on the meta language(s): the object language concerns formulas in calculations, which employ rewriting to a large extent; the meta language concerns specifications and programs (in TP-LP), which are evaluated by rewriting as well.

So efficiency of the rewriter is crucial; since Isabelle's rewriter is extremely efficient, ISAC shall adopt as much as possible from Isabelle, in particular term nets. Additional features of ISAC's rewriter shall be investigated for adaption to Isabelle's rewriter: 'reverse rewriting', calling ML code and modularisation into sub-simpsets (required for readable traces).

Investigate interactive TP-services for TP-LP programmers
In an educational math assistant at the state-of-the-art all calculations should be proved correct. Such obligations for verifying are concern of the programmer.

This sub-project shall investigate situations where TP-services are required by programmers, and how the TP-services could be smootly integrated into program development.

The utmost benefit from formal treatment of programs is mechanised code generation -- this task also shall investigate how Isabelle's code generator could be made available for TP-PL programs.