TU Delft LA-system

        e-learning tutor for math


        There is a growing demand for e-learning tools to improve math skills at the university. Students start nowadays less prepared with their university study due to chances at the secondary school. During their first year at the university, students are fully engaged in more active types of learning (projects, group work) and easily neglect their math classes. After failing the first examinations, there is not much opportunity to repair their deficiencies, hence the need for facilities to support self study.

        Several web-based tutor systems have been introduced lately, such as Aleks , My Math Lab and WebAssign . These interactive web sites offer a large collection of exercises, in addition to web lectures and explanations. Students can check whether their answer is correct and can ask for hints or see full worked-out examples. However, what really lacks is direct feedback. If the student is stuck or has made an error then there is no support to explain what he has done wrong and how he should proceed.

        The SURF-project "Intelligent feedback" has developed techniques to track a student while making an assignment. With a special developed strategy language, all possible paths to a solution can be described compactly, and the actions the student takes can be compared with the prescribed strategy. With this information, direct and meaningful feedback can be given.

        E-learning with intelligent feedback

        A consortium of computer scientist and mathematicians from the Open University in the Nederlands, Eindhoven University of Technology, and Delft University of Technology, has developed several tools applying the new strategy language and parser. One of these tools, the LA-system (for Linear Algebra) of Delft, is an interactive tutor system developed on top of Mathematica. The system has a graphical front-end for formula formatting. An exercise can be made by graphical selecting terms of an equation and applying operations chosen from a menu. The system carries out the operations and after a number of steps, typically in the order of five till ten, the exercise is solved. The interface of the system is comparable with MathXpert and DirectMath . See the next section for an example.

        Although the system offers at each step a number of feasible operations, the student still has to choose the correct one. It is not feasible to reach the solution without knowing where to head. The tool eliminates a lot of the nitty-gritty hand work of rewriting complex formulas and matrices, and allows students to concentrate on the strategies to solve the exercises. Further, the system can now follow the student step by step and provide adequate feedback.

        The operations that can be specified are based on a "rule set", a collection of rewrite rules implemented in Mathematica. The rule set is domain specific, i.e. for each topic within calculus and linear algebra, different sets of rewrite operations are needed. However, with a given rule set, a large number of exercises can be created. The level of the rewrite operations can be adapted, such that novice users can be offered basic step-by-step procedures, while more advanced users can rely on more powerful procedures and short cuts.


        To give an idea of how the system works we show a simple exercise. The system starts with offering two windows: the working window, that shows the exercise, and the rule window that gives the operations to manipulate the equations in the working window. (See Figure 1).

        Figure 1. Working window with equations (left) and the rule window (right). There are no rules specified yet, because there is no term selected so far.

        To proceed, the student first selects a term that he wants to re-write. The system now offers a number of feasible operations in the rule window. This gives the situation of figure 2.

        Figure 2. Selecting the set of equations brings verschijnen in het regel-window de toepasbare regels.

        Selecting the rule "Convert set of equations to augmented matrix" rewrites the set of equations to a matrix and the first step towards the solution is taken (Figure 3).

        Figure 3. The applied rule is listed between the old and the new formulation.

        After a number of steps we reach the situation of figure 4.

        Figure 4. Completed exercise.

        There may be multiple paths towards a solution, both in the order of steps, as well as in the strategy, eg. with or without use of an augmented matrix. By being able to recognize and analyse the chosen strategy the system can provide semantically-rich feedback.

        Strategy language and parser

        The parser interpretes the steps the student takes and compares them with the possible paths specified in the strategy. The strategy language is designed to compactly represent all possible sequences and allowable permutations. For instance, (3 + 5) * 4 can be calculated by first adding 3+5, but the student could as well have chosen for the more complex but also correct sequence of first eliminating the brackets, i.e. 3*4 + 3*5.

        The strategy language may contain strategy rules, rewrite rules, and code blocks. A strategy rule is of the format:

          Strategie := term, term, term....

        A term can be the name of a (sub)strategy (starting with an upper case character), or the name of a rewrite rule (starting with an lower case). The strategy rule specifies in which order the rewrite rules are to be applied.

        A term can also be a code fragment to execute some Mathematica code. The variables (names with a $-prefix) used within the code block can be passed as arguments to a strategy or rewrite rule, for example:

          multiply[$x] - multiplies the selected term with the value of $x.

        For a certain strategy we may specify multiple, alternative, rules. This is the power of the strategy language. The language has a special 'parallel' operator to execute strategies in parallel, and a 'not' operator to test whether a strategy still goes for a certain expression. With these constructs we can define complex strategies compactly.
        Below we give the strategy for the example of figure 1 which solves a set of linear equations by row reducing a matrix (Gaussian elimination). First the set of equations is converted into an 'augmented matrix' en then the matrix is brought into the reduced echelon form (with only 1's at the diagonal and zero's under the diagonal and above the diagonal). Then the matrix is converted back to a trivial set of equations. If there is an inconsistent equation eg. (0=1) then the set of equations does not have a solution. If there are one or more free variables, the user has to specify the requested parameters, and the set of equations can be rewritten to a vector/parameter representation of a point, line or plane.

        The code below is a simplified version of the real syntax.

        SolveLinearEqns := // strategy to solve a set of linear equations
        eqns2aug, // convert to augmented matrix
        MakeReducedEchelon, // rewrite to reduced echelon form
        aug2eqns, // convert back to equations
        GiveSolution, // if consistent: specify solution
        nosolution] // if not consistent: reply: 'no solution'

        GiveSolution := // strategy for specifying the solution
        Code[$freevars = FreeVariables[$CurrentTerm]],
        ForEach[$var,// for each $var
        $freevars,// out $freevars
        assignparam[$var]], // assign parameter to $var
        eqns2eq,// rewrite to vector/parameter representation

        MakeReducedEchelon := // rewrite to reduced echelon form
        ForwardPass,// bring into echelon form
        BackwardsPass// get rid of as much zero's above diagonal

        ForwardPass := // bring into echelon form
        FindColumn,// find next pivot column
        ExchangeNonZero,// exchange rows when needed
        ScaleToOne,// make pivot 1
        MakeZeroesFP// make zero's under pivot

        BackwardPass := // reduce zero's above the diagonal
        Code[$nonzerorows = Select[Rows[$CurrentTerm],!ZeroVector]]
        ForEach[$row,// for each row
        $nonzerorows// with other values than zero
        MakeZeroesBP// make zero's above pivot


        The strategy can be used to generate automatic feedback. At each point the system can track the user to see whether he is still on track. Feedback can be given to the user when:

        • an alternative path is taken, which leads away from the shortest path but may still lead to the correct solution

        • a step is taken which irrevocably diverts from the correct solution.

        In the first case, the system can give a hint to return to the shortest path, although the system can also wait a while until the user recognizes his error. In that case the system should be able to recognize "detour" strategies. In the second case the system could give feedback immediately and explain why the chosen option is not correct and how to proceed. In that case it would be beneficial if the strategy could also include well-known "pitfalls". These would be errors that are easily made and are known by the instructor. The "detour" and "pitfall" options are currently being implemented.

        The student can also ask for a hint. Depending on the pedagogical strategy there are several options:

        Hint On request, the system can give a strategic hint that does provide some insight but does not give away the complete solution. The full strategy can be decomposed into several steps and substrategies. The system can first base the hint on the highest level in the strategic hierarchy (see "Solve Linear Equation" in the above example). When the student is inside a substrategy, the system could give a hint related to the highest level within that procedure, and descend until the next elementary step.

        Next step The system shows the next step. This is only of value when the student understands the strategy, but does not know which rule to apply.

        Full solution The system shows the complete procedure. This is only of value when the student does not understand the strategic hints at all.


        The LA-system is implemented in Mathematica. You will need a full copy of Mathematica; the LA-system will not work with the free Mathematica Player.

        Download the latest LA-system:

        Installation instructions are found in the included README.txt. Exercise files and documentation are included in the distribution.


        Download the LA-system user manual (version 20090818, PDF).

        Download the strategy parser user manual (version 20070827, PDF).

        Download the strategy parser technical manual (version 20070807, PDF).


        Exercises are coded in Mathematica Notebook files. Some examples (also included in LA-system distrubution) can be found here.


        The LA system source code is distributed under the BSD Licence.

        Documentation and exercises are distributed under the Creative Commons Attribution 3.0 License.


        Contact: Erik Jansen

        This project was sponsored by the SURF Foundation, which initiates, coordinates and stimulates ICT innovations within higher education and research. See www.surf.nl.

        Copyright 2009 Delft University of Technology, The Netherlands. All rights reserved.