Abstract not found

The explicit teaching knowledge implemented in the current generation of Intelligent Tutoring Systems (ITSs) concerns mostly domain-based aspects of instructional processes, overlooking motivational aspects. This paper describes an instructional planner able to make decisions (about the next task to do, whether to provide hints, etc.) in order to achieve two goals: traversing the domain ⎯ domain-based planning ⎯ and maintaining the learner’s optimal motivational state ⎯ motivational planning. The traditional ITS architecture is extended to include the activities of motivational state modelling and motivational planning. For example, in motivational state modelling further learners ’ characteristics are diagnosed, e.g. effort and confidence. Sometimes the advice offered by a motivational planner disagrees with a domain-based plan, while in other cases both plans complement each other. A method of negotiation between the motivational plan and the domain-based plan is provided in order to arrive at a decision for action by the tutor.

This paper presents an overview and a survey of logic program synthesis. Logic program synthesis is interpreted here in a broad way; it is concerned with the following question: given a specification, how do we get a logic program satisfying the specification? Logic programming provides a uniquely nice and uniform framework for program synthesis since the specification, the synthesis process and the resulting program can all be expressed in logic. Three main approaches to logic program synthesis by formal methods are described: constructive synthesis, deductive synthesis and inductive synthesis. Related issues such as correctness and verification as well as synthesis by informal methods are briefly presented. Our presentation is made coherent by employing a unified framework of terminology and notation, and by using the same running example for all the approaches covered. This paper thus intends to provide an assessment of existing work and a framework for future research in logic program synthesis.

ion Selection Specialization P1/A1 Pn/An S1/G 1 Sn/G n S/G P/A 8 Abstraction For each program P i (i=1, ... , n) we identify a program schema S i which describes P i abstractly. This abstraction generates a set of substitutions q i for schema variables. The same abstraction leads from the literals A i to the abstract literals G i . In short, the abstraction step replaces each term P i /A i by its abstraction S i /G i , and we have P i /A i = S i q i /G i q i . Selection Transformation schemata transform the set of abstract terms {S 1 /G 1 , ... , S n /G n } into an abstract term S/G, i.e. a transformation schema is defined as {S 1 /G 1 , ... , S n /G n, S/G}. In general there are several transformation schemata which have {S 1 /G 1 , ... , S n /G n } as input. We select the transformation schema which generates a desired output program schema S together with an abstract literal G. Specialization We apply the substitution q = q 1 ... q n to S/G to get the transformed pr...

This paper describes a working prototype system which uses descriptions of standard Prolog techniques to provide a basic techniques editing system, ultimately intended for use by novice programmers. A notation for representing techniques, based on Definite Clause Grammars, is described in the context of previous theoretical work by Kirschenbaum, Lakhotia and Sterling. Details are supplied of a mechanism for using these techniques to provide guidance during program construction and an example is provided of the system in operation. I conclude by suggesting the extensions needed in order to make the prototype useful for practical applications. 1 Introduction Many people have expressed an interest in supplying software tools which will make Prolog programming easier and/or more efficient. Most of the effort of implementation seems to have been directed at the debugging phase and there seem to be very few implementations of systems which provide help with the initial construction of progr...

Abstract. Program schemata and programming techniques provide a mechanism for representing the essential characteristics of logic programs. By abstracting out common recursive control flow patterns, program schemata capture large classes of logic programs. Programming techniques represent common program components. By instantiating portions of program schemata with programming techniques, it is possible to generate arbitrary logic programs. In order to represent program schemata and programming techniques for any programming language, it is desirable to use a higher-order programming language as the representation language. �Prolog is a higher-order logic programming language that extends Prolog by incorporating higher-order unification and �-terms, making it an ideal logic programming language for representing logic program schemata and programming techniques. Because �Prolog program schemata and programming techniques can be represented in �Prolog, there is no need for the creation of an abstract meta-language in order to define and classify logic program schemata and programming techniques. 1

. Schema-based transformational systems maintain a library of logic program schemata which capture large classes of logic programs. One of the shortcomings of schema-based transformation approaches is their reliance on a large (possibly incomplete) set of logic program schemata that is required in order to capture all of the minor syntactic differences between semantically similar logic programs. By defining a set of extensible logic program schemata and an associated set of logic program transformations, it is possible to reduce the size of the schema library while maintaining the robustness of the transformational system. In our transformational system, we have defined a set of extensible logic program schemata in #Prolog. Because #Prolog is a higher-order logic programming language, it can be used as the representation language for both the logic programs and the extensible logic program schemata. In addition to the instantiation of predicate variables, extensible logic program sc...

: This paper outlines a logic programming methodology which applies standardized logic program recursion forms afforded by a system of general purpose recursion schemes. The recursion schemes are conceived of as quasi higher-order predicates which accept predicate arguments, thereby representing parameterized program modules. This use of higher-order predicates is analogous to higher-order functionals in functional programming. However, these quasi higher-order predicates are handled by a metalogic programming technique within ordinary logic programming. Some of the proposed recursion operators are actualizations of mathematical induction principles (e.g. structural induction as generalization of primitive recursion). Others are heuristic schemes for commonly occurring recursive program forms. The intention is to handle all recursions in logic programs through the given repertoire of higher-order predicates. We carry out a pragmatic feasibility study of the proposed recursion operator...

After their beginnings in computer-aided instruction, automated tutors have re-emerged as intelligent tutoring systems. These intelligent tutors have obtained considerable success by using results from cognitive psychology and artificial intelligence to permit non-traditional instruction which is tailored to their individual students. The success of these automated tutors is due to their precise understanding and modeling of both the student and the domain being taught. A common measure of the robustness of an automated tutor is the size of the domain that it can understand. The schema-based Prolog tutor described in this dissertation is capable of recognizing a larger class of programs than existing Prolog tutors. By using powerful generalized transformations, our Prolog tutor can generate this class of programs from a very small set of normal form programs. Thus, our Prolog tutor recognizes a larger class of programs using fewer normal form programs than existing Prolog tutors. One o...

This paper should replace a previous work entitled Enhanced Schema-Based Transformations for Logic Programs and their Opportunistic Usage in Program Analysis and Optimisation (Technical Report 95-16, Institut fr Informatik, Universitt Zrich), extending and updating it