Embed Size (px)
Citation preview
ARTICLE IN PRESS
Engineering Applications of Artificial Intelligence 21 (2008) 733– 743
Contents lists available at ScienceDirect
Engineering Applications of Artificial Intelligence
0952-19
doi:10.1
� Corr
E-m
(E. Onai
journal homepage: www.elsevier.com/locate/engappai
Planning and scheduling in an e-learning environment.A constraint-programming-based approach
Antonio Garrido �, Eva Onaindia, Oscar Sapena
Sistemas Informaticos y Computacion, Universidad Politecnica de Valencia, Camino de Vera s/n, 46022 Valencia, Spain
a r t i c l e i n f o
Article history:
Received 29 January 2008
Accepted 1 March 2008Available online 22 April 2008
Keywords:
Planning
Scheduling
e-Learning
Learning routes
Constraint programming
Optimisation
76/$ - see front matter & 2008 Elsevier Ltd. A
016/j.engappai.2008.03.009
esponding author. Tel.: +34 963877007; fax:
ail addresses: [email protected] (A. Garrid
ndia), [email protected] (O. Sapena).
a b s t r a c t
AI planning techniques offer very appealing possibilities for their application to e-learning
environments. After all, dealing with course designs, learning routes and tasks keeps a strong
resemblance with a planning process and its main components aimed at finding which tasks must be
done and when. This paper focuses on planning learning routes under a very expressive constraint
programming approach for planning. After presenting the general planning formulation based on
constraint programming, we adapt it to an e-learning setting. This requires to model learners profiles,
learning concepts, how tasks attain concepts at different competence levels, synchronisation constraints
for working-group tasks, capacity resource constraints, multi-criteria optimisation, breaking symmetry
problems and designing particular heuristics. Finally, we also present a simple example (modelled by
means of an authoring tool that we are currently implementing) which shows the applicability of this
model, the use of different optimisation metrics, heuristics and how the resulting learning routes can be
easily generated.
& 2008 Elsevier Ltd. All rights reserved.
1. Introduction
Automated planning is an attractive area within AI due to itsdirect application to real-world problems. Actually, most everydayactivities require some type of intuitive planning in terms ofdetermining a set of tasks whose execution allows us to reachsome goals under certain constraints.
This direct application, the benefits it reports and, finally, theadvances on the research in AI planning have facilitated thetransfer of planning technology to practical applications, rangingfrom scientific and engineering scopes to social environments.Particularly, social environments such as education constitute anattractive field of application because of its continuous innovationand use of ICT (Information and Communication Technologies).However, it is generally agreed that education has not yet realisedthe full potential of the utilisation of this technology. As explainedin Manouselis and Sampson (2002), this is mainly due to the factthat the traditional mode of instruction (one-to-many lecturing orone-to-one tutoring), which is adopted in conventional education,cannot fully accommodate the different learning and studyingstyles, strategies and preferences of diverse learners. But now,conventional education is giving way to e-learning environments,which require learners to take the learning initiatives and control
ll rights reserved.
+34 963877359.
how knowledge is presented during instruction (Atolagbe, 2002),which is not a simple task. Particularly, many European countriessigned the Bologna joint declaration of the European space forhigher education,1 which entails an important change in thelearning process. With this declaration, learner’s roles are muchmore dynamic, active and autonomous. The amount of one-to-many lecturing decreases and significantly increases the amountof self-learning through the construction of coherent learningroutes according to a certain instructional course design. Finally,this course design recommends sequence of educational tasks andmaterial, tailored to individual learners needs and profiles.
In this paper we address the automated construction oflearning routes from the viewpoint of planning based onconstraint programming. After all, generating a learning routerepresents a planning activity with the following elements:learning goals to be attained, profile-adapted tasks with theirprerequisites and learning outcomes (i.e. preconditions andeffects, respectively), non-fixed durations, resources, orderingand synchronisation constraints, and collaboration/cooperationrelations. The underlying idea is to plan a learning route,indicating which tasks must be done, for a learner with a givenprofile in order to reach some learning goals. The general schemeis shown in Fig. 1. First, an instructional course design is defined
1 Available at http://ec.europa.eu/education/policies/educ/bologna/bologna.
pdf (accessed January 2008).
ARTICLE IN PRESS
Fig. 1. General scheme for planning individual learning routes.
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743734
by means of a visual authoring tool. This course is extended withthe additional, particular constraints of each application contextand, all together, is translated into a constraint programmingmodel that is later solved by a CSP solver. Finally, the outputsolution provides a learning route per learner, that is a profile-adapted plan. Each individual route consists of a sequence oftasks, such as attending an in-person lesson, doing a lab exercise,writing a report, etc. Although intuitively each course-plan isinitially created individually for each given learner, there are someparticular tasks that need to be done simultaneously by severallearners, such as attending a lab for the same practice work.Additionally, these tasks may require some type of synchronisa-tion (for instance, doing a working-group task), where the startand/or end must happen at the same time. Thus, a learning routealso requires the time allocation of its tasks according to thetemporalþ resource constraints, i.e. when the tasks will be done(scheduling component), which are encoded as additionalconstraints. In this context, the planning component is notparticularly costly since the plan is usually small; the number oftasks is between 10 and 20 per route, though there may be a lot ofdifferent alternatives. On the contrary, the scheduling componentis more significant because of the resource availability, thediversity of constraints and their handling and synchronisationamong different routes. These features are not easily included intraditional planning as they require artificial mechanisms to bemanaged, which complicate the planning algorithms. For instance,a very frequent type of constraints in an e-learning scenario suchas synchronisation constraints, where several actions need tomeet throughout a whole interval, is not easily represented andhandled in planners.
Our approach for planning learning routes relies on theconstraint programming formulation presented in Garrido et al.(2006), previously based on Vidal and Geffner (2006), whichencodes all type of constraints derived from both planning andscheduling features. Such a formulation provides a high level ofexpressiveness to deal with all the elements required in ane-learning setting and it has several advantages:
�
It is a purely declarative representation and, consequently, itcan be solved by any type of CSP solver. Obviously, by any typeof CSP solver we mean a solver that supports the expressive-ness of our constraint model, which includes binary and non-binary constraints. In any case, a non-binary constraint can be
translated into a binary one by creating new variables andconstraints (Bacchus and van Beek, 1998), though this wouldincrease the complexity of the model.
� The whole formulation is automatically derived from the coursedesign, without any need of specific hand-coded domainknowledge. This means that no expert users are required todevelop our constraint model as it is straightforwardly generatedfrom the tasks and relations provided in the instructional course.Despite this, specific ad hoc control information in the form ofhand-coded domain knowledge or domain-dependent heuristicscan be easily included in the formulation to find a better plan ormake the resolution process more efficient.
� Formal properties, such as soundness, completeness andoptimality, hold in our constraint model. In particular,optimality is a major issue in this context and so differentoptimisation multi-criteria can be defined w.r.t. the number ofactions of the learning routes, the duration of their tasks or thecost associated to them.
In summary, this paper introduces a formulation of planningproblems by means of constraint programming and the applicationof such a formulation to solve a learning-route planning problem.
This paper is organised as follows. In the second section wepresent some basic background on e-learning environments andtheir relation to AI planning, motivating some needs for using aconstraint programming approach. The third section brieflyreviews the formulation of a planning problem by means ofconstraint programming, while in the fourth section this formula-tion is adapted to fit an e-learning scenario, which imposes someparticular requirements. In the fifth section an example ofapplication is analysed, showing part of the formulation, im-plementation and results. Finally, we present the conclusions ofthe paper and point some directions for future work.
2. e-Learning and AI planning
The application of AI planning techniques has reportedimportant advances in the generation of automated courseswithin e-learning. One of the first attempts in this direction wasthe work in Peachy and McCalla (1986), in which the learningmaterial is structured in learning concepts and prerequisiteknowledge is defined, which states the causal relationship
ARTICLE IN PRESS
Table 1Main differences (and similarities) between e-learning and planning settings
e-Learning Planning
Knowledge
representation and
definition
Graphic workflow Plain-text file (PDDL)
Structural elements Learning tasks
(prerequisites and
outcomes)
Actions (preconditions
and effects)
Duration of tasks Non-fixed Fixed (non-fixed is
unusual)
General type of
constraints
Task– task and
task– outcome
orderings
Causal-links
Other constraints Deadlines,
synchronisation and
collaboration and/or
cooperation relations
Uncommon (time initial
literals)
Type of effects Monotonically
increasing (incremental
process)
Any type
(þ ¼;� ¼; � ¼; = ¼ and
:¼)
Domain of variables Numeric (marks,
evaluations, etc.)
Numeric planning
(more difficult than
traditional planning)
Type of plan Sequential (per learner)
and parallel (for
multiple learners)
Sequential or parallel
Quality assessment Resource usage/cost,
number of actions or
any multi-criteria
combination
Cost of the actions or,
usually, planning
metrics
2 Vrakas et al. (2007), personal communication.
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743 735
between different concepts. This instructional method was one ofthe first approaches to combine instructional knowledge andartificial intelligence planning techniques to generate sequencesof learning materials. In the same direction, Vassileva (1997)designed a system that dynamically generates instructionalcourses based on an explicit representation of the structure ofthe concepts/topics in the domain and a library of teachingmaterials. Other approaches have introduced hierarchical plan-ners to represent pedagogical objectives and tasks in order toobtain a course structure (Ullrich, 2005). Most recent works, suchas the one presented in Vrakas et al. (2007), incorporate machinelearning techniques to assist content providers in constructinglearning objects that comply with the ontology concerning bothlearning objectives and prerequisites.
Although the task of designing learning routes for e-learningenvironments has been accomplished from different perspectives,one of the most intuitive approaches is the instructional planningdesign (van Marcke, 1992), which is based on learning outcomes,information processing analysis and prerequisite analysis (Smithand Ragan, 2005). Therefore, e-learning can be considered as aparticular planning domain with specific constraints.
The underlying idea about instructional planning is to providea constructivist learning strategy based on both instructionaltasks and instructional methods, i.e. representations of differentroutes to achieve the goals. As depicted in Fig. 1, an expert user,usually a teacher or instructor, designs a course as a set of learningtasks with prerequisites that are required prior to the execution ofthe task, learning outcomes that are attained after the executionand a positive duration. The task duration is usually a non-fixedvalue because in a learning environment this value cannot beprecisely determined in advance as it varies among learners.Additionally, the instructor can define task–task and/or task–out-come constraints as well as deadlines to attain the learning goals.The main aim of an instructional session is to find a valid learningroute for a learner to achieve the learning goals, on the basis ofhis/her particular constraints (e.g. personal profile, previousknowledge, resource availability and temporal constraints). Inother words, an instructional design determines which learningtasks are present and in which order by using a structure ofconcepts/topics and tasks. As can be noted, an instructional designkeeps a strong resemblance with a plan, as it is usually modelledin AI planning. Analogously, the elements necessary for thisdesign are similar to the elements traditionally defined inplanning, since tasks can be expressed in terms of actions withduration, prerequisites and effects.
First, the course design defined by the instructor may be seenas a planning domain which contains the tasks that can be used toform the final learning routes. There is, however, slight differencesin the way the e-learning domain knowledge is represented, asindicated in Table 1. While a planning domain is represented as aplain-text file (e.g. PDDL format, Gerevini and Long, 2006), acourse design is commonly represented in a graphic way, thusexplicitly modelling the structural relations between tasks. Thereason for this is clear: the instructor who defines the coursedesign neither needs to be an expert in route modelling languagesnor needs to be interested in their syntax details. On the contrary,a graphic representation turns out to be more useful whenshowing the workflow among tasks (see Fig. 4).
Second, a learning task is equivalent to an action. A task hasprerequisites and learning outcomes, analogously to the condi-tions and effects of an action. Although a non-fixed duration is nota common feature in planning, where the duration of the actionsis well-known, this does not involve any difficulty in a constraintprogramming setting as it can be simply modelled by creating anew variable in the problem that represents such a duration (seenext section for more details). Regarding the definition of
constraints, there exist two basic types: task–task and task–out-come ordering constraints and/or deadlines. These types ofconstraints are not commonly used in planning (particularly,orderings are only due to causal link relations) but their definitionwithin constraint programming is straightforward. As we willdiscuss later, other more elaborate constraints can be definedsimilarly and easily, which makes a constraint programmingsetting more appealing than traditional planning.
Third, prerequisites and learning outcomes, also known asknowledge objects or simply as concepts, can be seen as fluentsthat are required/achieved by tasks. In planning, fluents canrepresent propositional or numeric information. In the former, thedomain is binary: the fluent (as a boolean proposition) is eitherpresent or not. In the latter, the domain can be defined as a real orinteger domain, where the range of possible values is significantlyhigher than two. In an e-learning environment all concepts arenumeric because no concept is entirely boolean; when a learnerperforms a task and achieves a concept it is not just as simple as toachieve or not achieve such a concept, but several levels ofachievement can be considered. This means that the planningprocess has to reason with numeric information in order to attainconcepts at a certain competence level, such as achieving a givenconcept at a level greater than 5. The way to achieve theseconcepts involves a subtle particularity as well. In traditionalplanning, actions modify their numeric effects in several ways byassigning a new value, increasing, decreasing or scaling its currentvalue. However, in an e-learning domain tasks only haveincreasing effects, i.e. tasks can only improve the value of aconcept but never worsen it. Using exclusively increasing effectsmeans that once a learner has attained a concept through theexecution of one or several tasks, no further tasks can lessen thecompetence level the learner has attained; that is, the learningprocess is a monotonically incremental process. Some authors2
ARTICLE IN PRESS
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743736
agree that performing tasks may alter the current knowledge state(value of the concepts) of the learners, diminishing and eveninvalidating some concepts already attained in the past. In aconstraint programming formulation this is possible by simplyexpressing such an alteration as a threat to be solved. However, formodelling this issue, we consider that implementing the idea offorgetting concepts, i.e. expressing limited persistence on con-cepts, is more suitable and appealing for a real e-learningenvironment. This way, we may include a concept-task temporalconstraint in the form: ‘a concept can only be used as aprerequisite for a task within 40 h of its achievement’. This typeof constraint can be easily modelled using the constraintprogramming formulation defined below.
Finally, quality assessment for learning routes plays a similarrole to the optimisation process in planning. Now, the optimisa-tion criterion can be seen from two different perspectives. Fromthe learner’s point of view, the criterion to be optimised is thelength of the learning route (plan), either in terms of number oftasks, their duration or difficulty level. It is important to note thatthe learning route of a learner is formed by a set of sequentialtasks. In planning terminology this implies having a sequentialplan per learner, where no tasks are executed simultaneously.Obviously, a learner cannot perform two tasks at the same time,but it is possible, and usually frequent, to have parallel plans fordifferent learners. From the expert or teaching centre point ofview, the criterion to be optimised may be associated to the cost ofthe tasks, usually given in terms of the cost of the used resources.For instance, if some tasks need an expensive resource then theoptimisation criterion will tend to reduce the usage cost byselecting alternative cheaper tasks. The optimisation of resourceusage and cost is more a scheduling feature than a planning oneitself, but a constraint programming formulation can combineboth features under the same model, which again makes aconstraint programming setting an interesting approach. Addi-tionally, a multi-criteria optimisation function that combines thetwo viewpoints can be easily defined to take into consideration amore representative metric.
3. Planning as a constraint programming formulation
In this section we present a general model to formulateplanning as constraint programming that will be used as a basisfor the e-learning scenario. Constraint programming formulationshave been used in many approaches to handle both planning andscheduling features. A common feature that appears in theseapproaches is that they rely on constraint satisfaction techniquesto represent and manage all different types of constraints,including the necessary constraints to support preconditions,mutex (mutual exclusion) relations and subgoal preserving. Thatis, they use constraint programming for planning by encoding aplanning problem as a CSP. Therefore, CSP formulations forplanning include reasoning mechanisms to represent and managethe causal structure of a plan as well as constraints that denotemetric, temporal and resource constraints. This general formula-tion through constraint programming has the ability to solve aplanning problem with very elaborate models of actions. More-over, automated formulations, like the ones presented in Vidaland Geffner (2006) and Garrido et al. (2006) have the advantagethat once the constraint programming model is formulated, theycan be solved by any type of technique implemented in the CSPsolver.
In a constraint programming setting, a problem is representedas a set of variables, a domain of values for each variable and a setof constraints among the variables. A feasible solution to thisproblem assigns to each variable a value from its domain that
satisfies all the problem constraints. In our model, variables arebasically used to define actions and conditions, both propositionaland numeric, required by actions, along with the actions thatsupport these conditions and the time when these conditionsoccur (time is modelled in R). Variables are defined for each actionpresent in the problem, which may comprise all actions of theplanning domain (after grounding all operators), or a smallersubset. Every action a is represented by the following basicvariables (Garrido et al., 2006):
�
SðaÞ; EðaÞ represent the start and end time of action a. � durðaÞ represents the duration of action a. � InPlanðaÞ encodes a binary variable that denotes the presenceof a in the solution plan.
� Supðc; aÞ represents the action that supports condition c foraction a, where c represents a fluent that can be eitherpropositional or numeric.
� Timeðc; aÞ represents the time when the causal link Supðc; aÞhappens; if c is a numeric condition, Timeðc; aÞ represents thetime when the action in Supðc; aÞ last updates c.
� Reqstartðc; aÞ and Reqendðc; aÞ represent the interval in whichaction a requires condition c. These variables provide a highexpressiveness for representing a wide type of conditions, frompunctual conditions when Reqstartðc; aÞ ¼ Reqendðc; aÞ to condi-tions required throughout an interval beyond the actionduration, for instance when Reqendðc; aÞ ¼ EðaÞ þ 5.
� Vactualðc; aÞ is a variable only used for numeric conditions whichdenotes the value of the corresponding fluent c at timeReqstartðc; aÞ if a requires condition c; otherwise, this variablestores the actual value of the numeric fluent at time SðaÞ.
� Vupdatedðc; aÞ represents the new value for the fluent c updatedby action a. This variable is only necessary in case a modifiesthe fluent c.
Example (Planning variables). Let us consider the actions shownin Fig. 2a, where the (propositionalþ numeric) preconditions tobe satisfied before the action starts are shown in the up-left angleof the action and the effects that are generated when theaction ends are shown in the down-right angle. If we focus onactions a1, a3 and a5, in addition to the basic variables SðÞ, EðÞ andInPlanðÞ, we have: Supðc4; a3Þ ¼ fa4g, Supðnc3; a5Þ ¼ fa2; a3; a6g,Supðc4; a5Þ ¼ fa4g; Timeðc4; a3Þ ¼ fEða4Þg, Timeðnc3; a5Þ ¼ fEða2Þ;Eða3Þ; Eða6Þg, Timeðc4; a5Þ ¼ fEða4Þg because all effects are gener-ated in the end of each action; Reqstartðc4; a3Þ ¼ fSða3Þg, Reqend
ðc4; a3Þ ¼ fEða3Þg, Reqstartðnc3; a5Þ ¼ fSða5Þg, Reqend ðnc3; a5Þ ¼fEða5Þg, Reqstartðc4; a5Þ ¼ fSða5Þg, Reqendðc4; a5Þ ¼ fEða5Þg if weassume that the preconditions must hold during the whole exe-cution of each action; Vactualðnc3; a3Þ¼finitial_ valueðnc3Þ;Vupdated
ðnc3; a2Þ;Vupdatedðnc3; a6Þg, Vactualðnc3; a5Þ ¼ finitial_valueðnc3Þ;Vupdatedðnc3; a2Þ; Vupdatedðnc3; a3Þ;Vupdated ðnc3; a6Þg as nc3 hasobviously an initial value and it can be also modified by a2, a3and a6; Vupdatedðnc3; a3Þ ¼ fVactualðnc3; a3Þ � 5g as a3 consumesfive units of nc3.
On the other hand, if we focus again on actions a1, a3 and a5 in
the plan shown in Fig. 2b, the values for their previously unbound
variables are finally: InPlanða1Þ ¼ InPlanða5Þ ¼ 1 and InPlanða3Þ ¼
0; Sða1Þ ¼ 0, Eða1Þ ¼ 2, Sða5Þ ¼ 4, Sða5Þ ¼ 5; Supðnc3; a5Þ ¼ a2;
Timeðnc3; a5Þ ¼ Eða2Þ; Vactualðnc3; a5Þ ¼ Vupdatedðnc3; a2Þ. Clearly,
as InPlanða3Þ ¼ 0 in Fig. 2b the values of their remaining variables
are not meaningful.
Constraints in our model represent relations among vari-ables and correspond to assignments and bindings of thevariables, supporting, temporal and numeric constraints. The
ARTICLE IN PRESS
Fig. 2. Example actions. (a) Shows the actions with their preconditions (up-left angle) and effects (down-right angle); ci stands for propositional condition, whereas nci
stands for numeric condition. The duration of the action is shown between brackets. (b) Shows a solution plan to find the goal c5. Note that replacing a5 by a6 would be also
a feasible solution for achieving c5, with the same number of actions but longer w.r.t. the length (makespan) of the plan.
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743 737
basic constraints defined for each variable that involves actiona are:
�
tha
SðaÞ þ durðaÞ ¼ EðaÞ binds the variables start and end of anyaction a.
� EðStartÞpSðaÞ represents that any action a must start afterfictitious action Start.3
�
EðaÞpSðEndÞ represents that any action a must finish beforefictitious action End. � Timeðc; aÞ represents the time when the action in Supðc; aÞ addsor updates (propositional or numeric) condition c. When c is anumeric condition, Vactualðc; aÞ ¼ Vupdatedðc; Supðc; aÞÞ. Addition-ally, Timeðc; aÞpReqstartðc; aÞ forces to satisfy condition c (eitherpropositional or numeric) before it is required.
� Condðc; aÞ ¼ Vactualðc; aÞ comp-op expression, where comp-op 2fo;p;¼;X;4;ag and expression is any combination ofvariables and/or values that is evaluated in R, which representsthe condition that the corresponding fluent c must satisfy in½Reqstartðc; aÞ;Reqendðc; aÞ� for action a. For instance, in Fig. 2aCondðnc3; a5Þ ¼ Vactualðnc3; a5Þ42. � Branching. jSupðc; aÞ ¼ bi ^ Supðc; aÞabjj 8bi; bj ðbiabjÞ thatsupports c for a, which represents all the possibilities tosupport c, one for each bi (while jSupðc; aÞj41).
� Solving threats. Let time_threatðbiÞ be the time when action bithreatens the causal link Supðc; aÞ, i.e. when bi changes thevalue of c generated by Supðc; aÞ. In that case, the constraintðtime_threatðbiÞoTimeðc; aÞÞ _ ðReqendðc; aÞotime_threatðbiÞÞ
must hold, which represents the idea of threat resolution byusing promotion or demotion.
� Solving mutexes. Let timeðbi; cÞ and timeðbj; cÞ (biabj) be thetime when bi and bj modify c, respectively; if c is apropositional fluent bi/bj generates/deletes c, whereas if c is anumeric fluent bi and bj give different values to c. Hence, 8bi; bj:timeðbi; cÞatimeðbj; cÞ must hold, which represents the mutexresolution between the two actions being executed in parallel:bi and bj cannot modify c at the same time.
This flexible formulation also admits the specification ofcomplex planning constraints such as persistence of concepts,temporal windows in the form of external constraints or generalcustomised n-ary constraints to encode complex constraints thatinvolve several variables of the model (Garrido et al., 2006). Notethat despite the high number of variables and constraints in themodel, they are only essential when involving actions with theirvariables InPlanðÞ ¼ 1. This means that when InPlanðaÞ ¼ 1 allvariables and constraints that action a involves need to beactivated, and deactivated otherwise like in conditional/dynamic
3 As commonly used in planning, we include two dummy actions Start and End
t represent the first and last action of the plan, respectively.
CSPs (Mittal and Falkenhainer, 1990) that support conditionalactivation of variables and constraints.
The expressiveness of this model formulation facilitates theencoding of any planning problem, from purely propositionalproblems to more elaborate domains which mix propositional andnumeric information, along with more complex constraints. Ingeneral, the resolution of the constraint programming model is ahard task, which becomes even more difficult when there existsmany variables to be instantiated and constraints to fulfill.However, the most costly task in the overall resolution processis selecting the values for variables Supðc; aÞ, i.e. establishing thecausal links of the actions that create the causal structure of theplan. On the contrary, this formulation model shows very efficientwhen the main aim is only to schedule plans or solve problemswith medium/low load of planning. In this case, variables InPlanðÞare already instantiated, i.e. the actions that form the plan arealready known, and the only task is to assign the execution timesof the actions to satisfy all problem constraints. In other words,this model turns out to be very appropriate in those problemswhere planning is not the big deal, that is, for pseudo-planning
problems with a high load of scheduling.
3.1. Use of heuristics
The success of planning highly relies on the heuristics used toreduce the search space, which may be huge even in small problems.A constraint programming solving process can adopt a similarsolution: devise heuristic estimations, automatically extracted fromthe problem definition, and include them in the constraintformulation, as lower and upper bounds to reduce the variablesdomain, thus avoiding unfruitful search. The underlying idea is touse estimations similar to the ones used in heuristic planning toapproximate the cost/time to support conditions or to start actionsfrom an initial state. The heuristic estimations can be calculated indifferent ways such as using relaxed planning graphs, relaxed plansor approximated (Bonet and Geffner, 2001; Do and Kambhampati,2001; Hoffmann and Nebel, 2001; Haslum, 2006). In particular, astraightforward heuristic calculated through a relaxed planninggraph can estimate the earliest time when an action can start as anoptimistic measure of reachability; that is, the distance between thedummy action Start and each action a, namely dðStart; aÞ. This way,the binding constraint EðStartÞpSðaÞ now becomes EðStartÞþdðStart; aÞpSðaÞ, which approximates significantly better the starttime of action a and helps reduce the search space.
In addition to the definition and use of heuristic estimations,other estimations can also be used in the CSP solver as branchingheuristics, i.e. heuristics to be applied at the branching point thatappears when supporting a causal link Supðc; aÞ. These heuristicscan be defined as the usual variable or value selection heuristics.In the former, the variable to be selected first can be that one with
ARTICLE IN PRESS
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743738
the max number of constraints, or that one with the min domainto help reduce the branching factor. In the latter, the heuristic canprovide an ordering criterion for the application of the actions faig
that support such a causal link (value ordering). For instance, theheuristic estimation may determine to select first action ai withmin value dðStart; aiÞ, i.e. the action that first appears, or simplythe latest to reduce the slack. It is obvious that these heuristicestimations are very valuable in a wide variety of problems withmany variables and constraints. Furthermore, we can apply othertechniques to the CSP engine that can also improve theperformance of the solving process, such as forward checking,arc-consistency or lookahead techniques.
An important advantage is that the application of heuristicstrategies as pruning mechanisms improves the overall solvingprocess thanks to the use of bounds that reduce the variablesdomain and help discard some unfeasible partial solutions. More-over, heuristic calculations, particularly those which are included inthe problem formulation, do not introduce an overhead in thesolving process as they can be computed in a preprocessing stagebefore solving the problem, making the heuristic computationindependent from the solving process itself.
3.2. Formal properties
This constraint programming formulation has a strong resem-blance with a POCL (partial-order causal-link) approach by combin-ing partial-order planning and least-commitment for reasoning oncausal links and threat resolution (Penberthy and Weld, 1992; Vidaland Geffner, 2006; Weld, 1994). Consequently, this formulationshares the same formal properties as a POCL approach such assoundness, completeness and optimality, making it an appealingframework for planning. Nevertheless, in order to guarantee thesenice properties during the CSP resolution some support on the CSPsolver side becomes necessary as well. First of all, soundness andcompleteness can be easily guaranteed by (i) the definition of themodel itself (this factor is independent of the CSP solver), because allthe alternatives to support causal links and solve threats andmutexes are considered and (ii) the completeness of the CSP solver.This guarantees that if there exists a solution it will be found by thesolver. Second, optimality can be also guaranteed when the CSPsolver performs an exhaustive, complete search until finding the bestquality solution. Obviously, optimality also depends on the granu-larity supported by the CSP solver. Let us assume a planning problemwith only two actions a and a0 with duration 1. Clearly, if the modelimposes an ordering constraint like SðaÞoSða0Þ and SðaÞ ¼ 1, thenSða0Þ ¼ 2 is an optimal solution if the CSP solver does not supportcontinuous domains, i.e. if all the domains of variables are discrete.But Sða0Þ ¼ 1:1 or Sða0Þ ¼ 1:01 would be also optimal solutions inhigher precision solvers. This means that all the ‘o’ or ‘4’constraints are internally managed by the solver like ‘p’ or ‘X’,respectively, plus the corresponding value of the solver’s precision.Although this may sound a bit odd, it is not particularly relevant forthe constraint programming formulation as plan validation andevaluation requires as input the minimal precision with which weevaluate the quality of the plans (Long and Fox, 2001).
All in all, we can conclude that this formulation provides ageneral and property-compliant model that can be used by manyCSP solvers and if the CSP solver performs a complete search thenthe solution will not be only sound but also optimal.
4. Adapting the constraint programming formulation fore-learning
As indicated in Section 2, e-learning can be seen as a particularplanning problem which, consequently, can be encoded as a
constraint programming formulation. However, the general con-straint programming formulation presented in the previoussection needs to be slightly changed in order to be adapted toan e-learning environment. On the one hand, the formulationmodel can be simplified because:
�
Variables and constraints for propositional information are notused in this environment, because no concept is entirelyboolean. In consequence, all variables and constraints in themodel involve numeric conditions now. � Variables Reqstart, Reqend are no longer needed; the highlevel of expressiveness that these two variables provide isunnecessary because conditions are required to be satisfiedonly at the beginning of each task and they are monotonicallyincremented.
� Mutex-solving constraints are now unnecessary as plans aresequential (per learner) and no tasks for the same learner areexecuted in parallel.
These simplifications imply a reduction in the model complex-ity. But, on the other hand, the formulation needs to be extendedto include some new additional requirements:
�
Extra constraints to guarantee a sequential plan per learner.Although different learners’ plans run in parallel, no actions forthe same learner are allowed concurrently. � Synchronisation constraints for working-group tasks. In ane-learning setting some tasks among several learners need tobe executed simultaneously and at a particular time (e.g.attending an in-person seminar activity that must fit in a labtimetable).
� Capacity constraints to avoid overexceeding resources capacitysuch as labs, classrooms, scarce devices, etc.
These extra constraints impose some new complexity on themodel, but on the other hand they help reduce the variabledomains, which in general makes the problem solving processeasier.
More formally, all the previous changes are encoded in theconstraint formulation in the following way:
�
Elimination of Reqstart, Reqend. This way, the constraintTimeðc; aÞpReqstartðc; aÞ now becomes Timeðc; aÞpSðaÞ. � Sequential plan per learner. Let Tli be the set of all possibletasks that a learner li could execute. The constraint8tj; tkðtjatkÞ 2 Tli : ðEðtjÞpSðtkÞÞ _ ðEðtkÞpSðtjÞÞ must hold.
� Synchronisation of working-group tasks. Let ftli ; tliþ1; . . . ; tliþng
be the tasks that learners li; liþ1; . . . ; liþn must, respectively,execute at the same time as a common working-group task.The constraint ðSðtli Þ ¼ Sðtliþ1
Þ ¼ � � � ¼ SðtliþnÞÞ ^ ðEðtli Þ ¼ Eðtliþ1
Þ ¼
� � � ¼ EðtliþnÞÞmust hold (obviously all the durations must be the
same). Additionally, if these tasks require a particular resourceRj, such as a lab, special equipment, etc., they need to fit in thetemporal window of the resource availability given by½minðtwðRjÞÞ;maxðtwðRjÞÞ�. Thus, the next constraint must alsohold: ðminðtwðRjÞÞpSðtli ÞÞ ^ ðEðtli ÞpmaxðtwðRjÞÞÞ.
� Resource capacity. Let T ¼ ftli ; tliþ1; . . . ; tliþng be the set of all
tasks that are executed concurrently (the starting and endingpoints, respectively, may coincide or not) by different learnersand require a given resource Rj. Assuming that these tasksconsume some quantity of resource Rj (denoted by useðtli ;RjÞ),the next constraint to avoid resource overconsumption musthold:
Pi¼1;...;n useðtli ;RjÞpCðRjÞ, where CðRjÞ is the max capacity
of resource Rj. This ensures that, at any time throughout theexecution of tasks in T, the sum of all the individual resource
ARTICLE IN PRESS
Fig. 3. A reinforcement task that could be executed several times. The task
requires some level of knowledge of a concept, supports the same concept (and
possibly others) and can be executed more than once. Generally, the instructor also
needs to specify the max number of repetitions to avoid infinite loops.
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743 739
consumption of the tasks does not exceed the resourcecapacity.
4.1. Repeating tasks. Breaking symmetry
In an e-learning setting it may be necessary to have tasks thatcan be executed more than once in order to achieve a particularknowledge level. This is the situation in which a task acts as areinforcement task (see Fig. 3), i.e. a task that a learner may needto execute several times, or simply a task that needs to berepeated when the learner fails to achieve its learning outcomes.This involves a high degree of flexibility in the education scenario,as the precise number of repetitions is chosen by the CSP solveraccording to the learner’s necessities or preferences. However, thisnumber of repetitions is not unlimited as there usually existeducational restrictions that prevent the learner from doing thesame task an infinite number of times.
In our constraint programming formulation, repeating tasksare modelled as other tasks with the only difference that oneindependent instance of each task is needed per repetition;actually, this means having different occurrences at differenttimes of the same task. Hence, if a task can be repeated at mostthree times, three tasks (trep1, trep2 and trep3) must be included inthe model. This is necessary to simulate the fact of having one,two or the three repetitions in the solution plan. Initially, all theinstances of the same task are clones that have the same domainand the same constraints. Later, the CSP solver may decide toinclude one or more of them in the plan, making InPlanðÞ ¼ 1 andkeeping the others untouched. The main drawback here is thatthis can entail a symmetry problem.4 During the solving process,any instance in ftrep1; trep2; trep3g can be planned, and in any order.Particularly, if the CSP solver selects first trep1 and this decisionleads to an unfeasible solution, the solver needs to backtrack.After this backtracking, the solver would select any instance inftrep2; trep3g, leading again to two unfeasible solutions, one afterselecting each trep2 and trep3, respectively. Loosely speaking, insuch a situation the CSP solver wastes a lot of effort trying to plan,unsuccessfully, identical tasks. This is a clear inefficiency that maylead to redundant search and significantly diminish the overallperformance of the search.
Fortunately, we can extend the constraint formulation to breakthis symmetry in an easy way. Let t be a task that can be repeatedat most n times. This makes necessary the generation offtrep1; trep2; . . . ; trepng instances in the model, with all theirvariables and constraints. Additionally, the following constraintsmust be also included:
for(i ¼ 1; ion; iþþ)
if InPlanðtrepiÞ ¼ 0 then InPlanðtrepiþ1Þ ¼ 0.
The purpose of this loop aims at generating constraints of thetype ‘if InPlanðtrep1Þ ¼ 0 then InPlanðtrep2Þ ¼ 0’, ‘if InPlanðtrep2Þ ¼ 0then InPlanðtrep3Þ ¼ 0’ and so on. Intuitively, these constraintsforce the CSP solver to plan the tasks InPlanðtrepiÞ in order. Forinstance, the task trep3 will not be planned unless both trep1 andtrep2 are in the plan, which prevents the search from analysingsymmetric situations, thus avoiding the inefficiency pointedabove.
4.2. Domain-dependent heuristics
When solving a planning problem, the use of adequateheuristics becomes essential to improve the efficiency of the
4 We thank Roman Bartak for pointing out this drawback.
search and, consequently, the overall performance. Clearly, thesame happens when solving a constraint satisfaction problem andespecially when the problem represents a planning problem thatcontains many variables and constraints. One of the most effectivepoints to apply heuristics is at the branching point, i.e. when theCSP solver needs to assign a value to the variables InPlanðÞ, SupðÞand SðÞ=EðÞ (note that the value of the remaining variables of themodel comes from a propagation of these variables). At this point,the heuristics that can be defined are the usual variable and valueselection heuristics aimed at reducing the branching factor, thatis, which variable to select first and which value to instantiatefirst, respectively. Traditionally, CSP heuristics use domain-independent information to establish this selection order, suchas first select the variable with the max number of constraintsinvolved, or the one with the min domain, or instantiate thevalues in an increasing, decreasing or random order. However, thismay not be the best approach to tackle an e-learning planningproblem as can be seen in the next example.
Let us assume an e-learning setting with the tasks Tl1 ¼
ft1l1 ; t2l1 ; . . . ; til1 g and Tl2 ¼ ft1l2 ; t2l2 ; . . . ; tjl2g that can be included in
the learning routes (plans) for learners l1 and l2, respectively.Since the goal of the CSP solver is to find which tasks will be partof the solution, a blind variable selection heuristic will try toinstantiate first the variables associated with task t1l1 , then t1l2 ,t2l1 , t2l2 and so on, i.e. alternating tasks of the two learners in abreadth first fashion. If there appears a conflict because of theselected tasks for a learner then a lot of unnecessary backtrackingwill be performed on the tasks of the other learner. For instance, iftask t1l1 is wrongly chosen then the CSP solver will need tobacktrack on the already-instantiated tasks t1l2 , t2l2 , etc. This willnever fix the problem of the wrong selection for learner l1 in theallocation of task t1l1 and, additionally, it will entail a lot ofthrashing. This indication of inefficiency is much more significantwhen the number of learners increases and, particularly, whenthey need to do almost identical tasks. Although there are someworks in domain-independent planning about more efficient waysto guide backtracking, learn from conflicts and exploit symmetrywhen planning as a CSP (Kambhampati, 2000; Zimmerman andKambhampati, 1999), we can apply a very effective domain-dependent heuristic for our e-learning scenario by simply group-ing together the variables related to the same learner. Thus, theselection strategy selects first the variables of one learner anddoes not proceed with a second learner until finding a validlearning route for the first one. This depth-first-like explorationturns out to be very effective in most situations. However, it mustbe noticed that it does not avoid backtracking in conflicting caseswhere different learners share the same oversubscripted resource.Actually, this simple strategy allows finding more learning routes
ARTICLE IN PRESS
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743740
for more learners in less time. Further, this heuristic has twoadditional advantages: (i) it is valid for any CSP solver and (ii) itdoes not introduce an overhead in the solving process as thevariable grouping can be computed before solving the problem,i.e. the grouping is independent of the solving process itself.
5. An e-learning scenario of application
In this section we present a simple e-learning scenario that willbe used as an application example to show how to plan learningroutes under a constraint programming approach. As part of anon-going national research project, we are implementing anauthoring tool in Visual C# to help design the e-learning course ina simple way (see Fig. 4). The underlying idea of this tool is to havea user-friendly graphical application with intuitive input forms, asshown in Fig. 5. These forms provide instructors support duringthe specification of a course by means of the definition of learnersprofiles, concepts, tasks and their relations. For our applicationexample, we assume that an expert defines the course designdepicted in Fig. 4, which consists of seven concepts (6þ 1previous concept) and nine tasks of different non-fixed duration.Note that Task5 can be executed up to two times, so actually themodel contains 10 tasks, including Task5rep1 and Task5rep2. Eachconcept represents a learning object, i.e. a knowledge item that
Fig. 4. Snapshot of the prototype for the authoring tool with the course design for the e
generated as effects, such as Concept4 or Concept6, are profile-dependent. The duration
the idea of actions, preconditions and effects used in planning.
can be attained from one or more tasks. Each task may represent adiscrete lesson, a seminar activity, a public talk or even a high-level course. Each learner can execute each task only once, withthe exception of Task5 that can be executed at most twice asindicated in Fig. 5 by its value max repetitions ¼ 2.
The course shown in Fig. 4 is appropriate for learners withdifferent learning styles, given by the input profile (visual orverbal) or the organisation profile (inductive or deductive),following the classification given in Felder and Silverman (1988).According to these profiles, learners can perform, or not, a giventask. Particularly, Task2 is only adequate for learners with a visualinput profile. Moreover, tasks attain concepts at differentcompetence levels (percentages) depending on the type of profilethey are suitable for. For instance, Task3 generates Concept4 atdifferent levels: if the learner is visual the task increases the valueof Concept4 in 50%, whereas it increases such a value in 75% if thelearner is verbal. We also assume that Task1 is an in-person lessonthat needs to be performed in a synchronised way for all thelearners, while Task4 requires a particular resource of maxcapacity 2, i.e. only two learners can perform such a tasksimultaneously.
We apply the previous design course in an e-learning scenariowith four learners with different profiles. Table 2 shows theprofiles for these learners, the initial values of prev-Concept1 andthe minimum competence levels required for Concept6, which, in
-learning scenario of application. Some tasks, such as Task2 or Task7, and concepts
of the tasks is indicated between brackets. Note that tasks and concepts represent
ARTICLE IN PRESS
Fig. 5. Some input forms of the authoring tool to define the properties of tasks, concepts and learners profiles. In addition to this information, essential for planning
e-learning routes, the tool also allows to define learning material (slides, multimedia documents, handouts, etc.), the types they belong to (visual, multimedia, Powerpoint
presentation, etc.) and the resources (computers, books, etc.) that they required.
Table 2Initial features of the four learners that represent a particular problem
Learner Profile prev-Concept1 Concept6
Learner1 Visual, inductive ¼ 25 X100
Learner2 Verbal, inductive ¼ 0 X75
Learner3 Verbal, deductive ¼ 50 X100
Learner4 Visual, deductive ¼ 0 X50
The initial value for the remaining concepts are initially 0.
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743 741
this example, is the final learning goal to be attained. Note that thecourse design represents a general domain of application that canbe used in many different scenarios (particular problems). Thisway, the same course can be used in another scenario with otherlearners, different profiles and with other learning goals and/orcompetence levels.
5.1. Formulation of the problem
According to the constraint programming model presentedabove, the formulation for Task2 (and its concepts) of Learner1includes the following variables and constraints:
�
InPlanðT2Þ 2 ½0;1�; � SðT2Þ; EðT2Þ 2 ½0;1½; � durðT2Þ 2 ½3;5�;�
SupðC1; T2Þ 2 fStart; T1g; � SupðC3; T2Þ 2 fStart; T3; T4g; � SupðC4; T2Þ 2 fStart; T3; T4; T5g; � TimeðC1; T2Þ;TimeðC3; T2Þ;TimeðC4; T2Þ 2 ½0;1½; � SðT2Þ þ durðT2Þ ¼ EðT2Þ; � EðStartÞpSðT2ÞoEðT2ÞpSðEndÞ; � TimeðC1; T2ÞpSðT2Þ, TimeðC3; T2ÞpSðT2Þ, TimeðC4; T2ÞpSðT2Þ; � if SupðC1; T2Þ ¼ Start then TimeðC1; T2Þ ¼ Start;if SupðC1; T2Þ ¼ T1 then TimeðC1; T2Þ ¼ T1;
� if SupðC3; T2Þ ¼ Start then TimeðC3; T2Þ ¼ Start;if SupðC3; T2Þ ¼ T3 then TimeðC3; T2Þ ¼ EðT3Þ;if SupðC3; T2Þ ¼ T4 then TimeðC3; T2Þ ¼ EðT4Þ;
� if SupðC4; T2Þ ¼ Start then TimeðC4; T2Þ ¼ Start;if SupðC4; T2Þ ¼ T3 then TimeðC4; T2Þ ¼ EðT3Þ;if SupðC4; T2Þ ¼ T4 then TimeðC4; T2Þ ¼ EðT4Þ;if SupðC4; T2Þ ¼ T5 then TimeðC4; T2Þ ¼ EðT5Þ;
� 8Ti (TiaT2) of Learner1: ðEðT2ÞpSðTiÞÞ _ ðEðTiÞpSðT2ÞÞ:The variables for other tasks of Learner1 and other learners aregenerated similarly, including the synchronisation constraint forTask1 and the resource capacity constraints for Task4. In additionto this, it is also necessary to define the metric function. Themetric to optimise may involve an expression with as manyvariables as the user requires, such as makespan (overall durationof the plan), number of tasks, cost of lab usage or any combinationof them. In our example we perform the optimisation task fromthe learners collective standpoint and apply two different
ARTICLE IN PRESS
Fig. 6. Learning routes (plan) for each of the four learners when minimising the number of actions to be executed. Note that: (i) Task1 is executed at the same time by the
four learners because of the synchronisation requirement of an in-person lesson and (ii) Task4 can be executed in parallel at most by two learners because of the capacity
constraint.
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743742
optimisation criteria. First, we optimise the number of actionsin the four learning routes, which means to find the solutionwith the min number of tasks (in a collective/joint way) to reachthe learning goals, i.e. we formulate the metric as: mini-mise(
PInPlanðtaski; learnerjÞÞ;8taski 2 fTask1 . . .Task9g; 8learnerj
2 fLearner1 . . . Learner4g. Second, we optimise the global make-span of the four learning routes which means the routes that leadto the shortest collective makespan, thus formulating the metricas: minimise(End), where End represents the last action of theplan.
5.2. Implementation and results
The constraint programming formulation is modelled andsolved by Choco.5 Choco is a Java library for constraint satisfactionproblems, which, by means of the implementation of a classproblem, allows the user to create variables and post n-aryconstraints in a constraint network. Choco performs a back-tracking search by selecting a value for each variable of the modeland propagates such a value throughout the constraint network,updating the lower and upper bounds of other variables.
In our implementation, we have modified the variable selectorof the Choco engine to take into consideration the problemvariables grouped by learner, analysing first Learner1, thenLearner2 and so on. During the solving process Choco tries tofind the best solution according to the optimisation metric, i.e.given a certain deadline Choco performs an exhaustive search ofsolutions until no feasible solution improves the quality of thebest solution found within the deadline or the allocated time isexceeded. In a problem like this, guaranteeing the optimalsolution is a very expensive task, but in most cases a goodsolution can be found in a few seconds. In general, Choco finds asolution very quickly and, in some cases, this turns to be theoptimal one, though this cannot be generalised.
Our experiments have been conducted on a 2.60 GHz. PentiumIV with 1280 Mb. of RAM running Fedora Core 4 Linux andcensored after 20 min. Particularly, if we focus on minimising thenumber of actions, Choco finds two solutions, the first one with 21tasks and the second one with 20, which is depicted in Fig. 6. Thefirst solution takes less than 2 s, the second one takes nearly 9 minand, after 20 min no better solution is found. On the other hand, ifwe focus on minimising the makespan Choco finds three solutionsof length 17, 16 and 15 (see the resulting plan in Fig. 7) in 1.7, 2.2and 2.8 s, respectively, exhausting the search space and thusguaranteeing that no better solution exists in less than 4 s.
5 Choco can be downloaded from http://choco.sourceforge.net.
Actually, as can be seen in both figures the two plans are nearlyidentical and the only difference appears for Learner1, who inFig. 6 takes one more action despite trying to minimise thenumber of actions in the plan. This indicates that the solver wasunable to find the optimal solution within the allocated time.Choco had to explore, practically, the whole search space and thisis because of the metric used, minimising the number of actions.As the cost of each action is exactly the same (one cost unit peraction), the pruning mechanism has very little information todiscriminate between alternatives and the search worked mostlyin a breadth first fashion, which is very expensive. On thecontrary, when minimising the makespan, Choco uses a moreprecise upper bound, thus pruning many partial solutions andexhausting the search space in a few seconds. In this case, sincethe cost of each action is different (action duration), the makespanof the solutions also differs between them and, consequently, thepruning mechanism is much more informed, making it possible todiscard more parts of the search space. Thereby, the metric to beoptimised can affect the complexity of the solving process,making it necessary to explore a bigger or smaller search space.Additionally, the use of heuristics can also play a valuable roleduring the search. The main advantage of this approach is that onecan include different heuristics in the CSP solver with no changesin the constraint formulation at all.
6. Conclusions
Constraint programming formulation is a very appropriateapproach to tackle planning problems that require the represen-tation and management of a wide range of complex constraints, asit is the case of e-learning environments. Designing a learningroute can be seen as generating a plan in a domain where it isnecessary to attain learning outcomes (concepts) while handlingresources and their capacity, synchronised tasks among learnersof different profiles, orderings between tasks, deadlines or othercustomised and elaborate constraints. In principle, as a planningproblem, the design of learning routes could be accomplished byusing a current state-of-the-art planner. However, current plan-ners cannot afford complex constraints as task synchronisation or,otherwise, it would be necessary many artificial tricks forrepresenting and handling it. On the other hand, optimality is amajor issue in e-learning contexts either from the learner orteaching centre viewpoint, so it is important to guarantee good-quality, and even optimal, plans as this might affect the overalllearning route.
In an e-learning context, the activity that requires a little bit ofeffort is the definition of the course design by the instructor. It isnecessary to classify the learning tasks, study the prerequisites
ARTICLE IN PRESS
Fig. 7. Learning routes (plan) for each of the four learners when minimising the makespan of the plan. Note, as in Fig. 6, the constraints on Task1 and Task4.
A. Garrido et al. / Engineering Applications of Artificial Intelligence 21 (2008) 733–743 743
and outcomes of each task by means of concepts, identify theprofiles for which the task is best focus, determine the assessmentpoints, establish the competence level for the concepts, etc. Inorder to make this task easier we provide a visual authoring toolthat allows the instructor to simply drag and drop elements froma tool bar for elaborating such a design in a simple and intuitiveway. As an additional advantage, since the course designcomprises the specification of a general, flexible learning domain,it can be used for the generation of learning routes in manydifferent contexts (teaching centres) with different time andresource constraints, for different learner profiles and withdifferent optimisation criteria. In other words, it is worth theeffort devoted to course design in favour of the reusability degreewe can obtain with our approach for planning routes in e-learningenvironments.
We can conclude by saying that the expressiveness ofconstraint programming makes it very appropriate for modellinglearning routes. The adequacy is also given by the fact thatdesigning learning routes is not a very complex planning problembut rather a complex scheduling problem. For this reason,constraint programming approaches seem to be a promisingdirection for e-learning contexts. As a consequence of this, we arecurrently working on two aspects. First, we are studying otherheuristic functions to make the solving process more efficient inorder to face bigger problems and improve the scalability of theapproach. Second, we are extending the authoring tool, aspresented in Onaindı́a et al. (2007), to make the definition ofthe course design even more intuitive by splitting it into threesteps: (i) define a conceptual design with the relations amongconcepts, (ii) define an instructional design with the tasks thatachieve the concepts, and (iii) define a planning design with allthe elements presented in this paper such as profiles, concepts,tasks, competence levels as percentages and complex constraints.
Acknowledgements
This work has been partially supported by the Spanishgovernment projects MEC TIN2005-08945-C06-06 (FEDER) andConsolider-Ingenio 2010 CSD2007-00022, and by the Valenciangovernment project GV06/096.
References
Atolagbe, T.A., 2002. E-learning: the use of components technologies and artificialintelligence for management and delivery of instruction. In: Proceedings of the24th International Conference on Information Technology Interfaces (ITI-2002), pp. 121–128.
Bacchus, F., van Beek, P., 1998. On the conversion between non-binary and binaryconstraint satisfaction problems. In: Proceedings of the 15th NationalConference on Artificial Intelligence. Madison, Wisconsin.
Bonet, B., Geffner, H., 2001. Planning as heuristic search. Artificial Intelligence 129,5–33.
Do, M.B., Kambhampati, S., 2001. Sapa: a domain-independent heuristic metrictemporal planner. In: Cesta, A., Borrajo, D. (Eds.), Proceedings of the EuropeanConference on Planning (ECP-2001), pp. 109–120.
Felder, R.M., Silverman, L.K., 1988. Learning and teaching styles in engineeringeducation. Engineering Education 78 (7), 674–681.
Garrido, A., Onaindı́a, E., Arangu, M., 2006. Using constraint programming to modelcomplex plans in an integrated approach for planning and scheduling.In: Proceedings of the 25th UK Planning and Scheduling SIG Workshop,pp. 137–144.
Gerevini, A., Long, D., 2006. Plan constraints and preferences in PDDL3.In: Proceedings of the International Conference on Automated Planningand Scheduling (ICAPS-2006)—International Planning Competition,pp. 7–13.
Haslum, P., 2006. Improving heuristics through relaxed search—an analysis of TP4and HSP*a in the 2004 planning competition. Journal of Artificial IntelligenceResearch 25, 233–267.
Hoffmann, J., Nebel, B., 2001. The FF planning system: fast plan generationthrough heuristic search. Journal of Artificial Intelligence Research 14,253–302.
Kambhampati, S., 2000. Planning graph as (dynamic) CSP: exploiting EBL, DDB andother CSP techniques in Graphplan. Journal of Artificial Intelligence Research12, 1–34.
Long, D., Fox, M., 2001. Encoding temporal planning domains and validatingtemporal plans. In: Proceedings of the 20th UK Planning and Scheduling SIGWorkshop, pp. 167–180.
Manouselis, M., Sampson, D., 2002. Dynamic knowledge route selection forpersonalised learning environments using multiple criteria. In: Proceedings ofthe Intelligence and Technology in Educational Applications Workshop (ITEA-2002), Innsbruck, Austria.
Mittal, S., Falkenhainer, B., 1990. Dynamic constraint satisfaction problems.In: Proceedings of the National Conference on Artificial Intelligence,pp. 25–32.
Onaindı́a, E., Sapena, O., Garrido, A., 2007. An AI planning-based approach forautomated design of learning routes. In: Proceedings of the 6th EuropeanConference on e-Learning (ECEL-2007), pp. 453–461.
Peachy, D.R., McCalla, G.I., 1986. Using planning techniques in intelligent systems.International Journal of Man-Machine Studies 24, 77–98.
Penberthy, J., Weld, D.S., 1992. UCPOP: a sound, complete, partial-order planner forADL. In: Proceedings of the International Conference on Principles of Knowl-edge Representation and Reasoning. Kaufmann, Los Altos, CA, pp. 103–114.
Smith, P.L., Ragan, T.J., 2005. Instructional Design, third ed. Wiley, New York.Ullrich, C., 2005. Course generation based on HTN planning. In: Proceedings of the
13th Annual Workshop of the SIG Adaptivity and User Modeling in InteractiveSystems, pp. 74–79.
van Marcke, K., 1992. Instructional expertise. In: Proceedings of the 2ndInternational Conference on Intelligent Tutoring Systems, vol. 608. Springer,Berlin, pp. 234–243.
Vassileva, J., 1997. Dynamic course generation. Communication and InformationTechnologies 5 (2), 87–102.
Vidal, V., Geffner, H., 2006. Branching and pruning: an optimal temporal POCLplanner based on constraint programming. Artificial Intelligence 170, 298–335.
Vrakas, D., Tsoumakas, G., Kokkoras, F., Bassiliades, N., Vlahavas, I., Anagnosto-poulos, D., 2007. PASER: a curricula synthesis system based on automatedproblem solving. International Journal on Teaching and Case Studies, SpecialIssue on ‘‘Information Systems: The New Research Agenda, the EmergingCurriculum and the New Teaching Paradigm’’. 1 (1/2), 159–170.
Weld, D., 1994. An introduction to least commitment planning. AI Magazine 15 (4),93–123.
Zimmerman, T., Kambhampati, S., 1999. Exploiting symmetry in the planning-graph via explanation-guided search. In: Proceedings of the NationalConference on Artificial Intelligence.
