Test Generation Based on CLP

Functional ATPGs based on simulation are fast, but generally, they are unable to cover corner cases, and they cannot prove untestability. On the contrary, functional ATPGs exploiting formal methods, being exhaustive, cover corner cases, but they tend to suffer of the state explosion problem when adopted for verifying large designs. In this context, we have defined a functional ATPG that relies on the joint use of pseudo-deterministic simulation and Constraint Logic Programming (CLP), to generate high-quality test sequences for solving complex problems. Thus, the advantages of both simulation-based and static-based verification techniques are preserved, while their respective drawbacks are limited. In particular, CLP, a form of constraint programming in which logic programming is extended to include concepts from constraint satisfaction, is well-suited to be jointly used with simulation. In fact, information learned during design exploration by simulation can be effectively exploited for guiding the search of a CLP solver towards DUV areas not covered yet. The test generation procedure relies on constraint logic programming (CLP) techniques in different phases of the test generation procedure. The ATPG framework is composed of three functional ATPG engines working on three different models of the same DUV: the hardware description language (HDL) model of the DUV, a set of concurrent EFSMs extracted from the HDL description, and a set of logic constraints modeling the EFSMs. The EFSM paradigm has been selected since it allows a compact representation of the DUV state space that limits the state explosion problem typical of more traditional FSMs. The first engine is randombased, the second is transition-oriented, while the last is fault-oriented. The test generation is guided by means of transition coverage and fault coverage. In particular, 100% transition coverage is desired as a necessary condition for fault detection, while the bit coverage functional fault model is used to evaluate the effectiveness of the generated test patterns by measuring the related fault coverage. A random engine is first used to explore the DUV state space by performing a simulation-based random walk. This allows us to quickly fire easy-to-traverse (ETT) transitions and, consequently, to quickly cover easy-to-detect (ETD) faults. However, the majority of hard-to-traverse (HTT) transitions remain, generally, uncovered. Thus, a transition-oriented engine is applied to cover the remaining HTT transitions by exploiting a learning/backjumping-based strategy. The ATPG works on a special kind of EFSM, called SSEFSM, whose transitions present the most uniformly distributed probability of being activated and can be effectively integrated to CLP, since it allows the ATPG to invoke the constraint solver when moving between EFSM states. A constraint logic programming-based (CLP) strategy is adopted to deterministically generate test vectors that satisfy the guard of the EFSM transitions selected to be traversed. Given a transition of the SSEFSM, the solver is required to generate opportune values for PIs that enable the SSEFSM to move across such a transition. Moreover, backjumping, also known as nonchronological backtracking, is a special kind of backtracking strategy which rollbacks from an unsuccessful situation directly to the cause of the failure. Thus, the transition-oriented engine deterministically backjumps to the source of failure when a transition, whose guard depends on previously set registers, cannot be traversed. Next it modifies the EFSM configuration to satisfy the condition on registers and successfully comes back to the target state to activate the transition. The transition-oriented engine generally allows us to achieve 100% transition coverage. However, 100% transition coverage does not guarantee to explore all DUV corner cases, thus some hard-to-detect (HTD) faults can escape detection preventing the achievement of 100% fault coverage. Therefore, the CLP-based fault-oriented engine is finally applied to focus on the remaining HTD faults. The CLP solver is used to deterministically search for sequences that propagate the HTD faults observed, but not detected, by the random and the transition-oriented engine. The fault-oriented engine needs a CLP-based representation of the DUV, and some searching functions to generate test sequences. The CLP-based representation is automatically derived from the S2EFSM models according to the defined rules, which follow the syntax of the ECLiPSe CLP solver. This is not a trivial task, since modeling the evolution in time of an EFSM by using logic constraints is really different with respect to model the same behavior by means of a traditional HW description language. At first, the concept of time steps is introduced, required to model the SSEFSM evolution through the time via CLP. Then, this study deals with modeling of logical variables and constraints to represent enabling functions and update functions of the SSEFSM. Formal tools that exhaustively search for a solution frequently run out of resources when the state space to be analyzed is too large. The same happens for the CLP solver, when it is asked to find a propagation sequence on large sequential designs. Therefore we have defined a set of strategies that allow to prune the search space and to manage the complexity problem for the solver

User-led Innovation in the UK National Health Service

Healthcare services are delivered to patients using complex technology systems. Many innovative healthcare technologies are produced by industrial suppliers; however, healthcare staff are also active innovators of the technologies that they use in their own work. By assuming the role of user-innovators, they can create new technologies, procedures, processes and service-designs that improve and support healthcare provision. The focus of the research reported in this thesis is the phenomenon of user-led innovation of healthcare technology in the UK National Health Service (NHS). Exploratory research was carried out to develop a detailed understanding of user-led innovation within the NHS based on the perspectives of user-innovators. This thesis presents the results of the research in the form of four interpretive case studies, that contribute to an understanding of the enabling and inhibiting factors affecting user-led innovation. Each case presents an overview of the process of user-led innovation which was followed and the context in which it occurred. Several distinctive characteristics of user-led innovation are identified and a generic activity model of the user-led innovation process is described. Evaluation in user-led innovation processes is highlighted to have multiple purposes,beyond objective technology assessment. It is shown to support the on-going social-construction of user-developed technologies but also highlights the role of evaluation as a resource for exercising political influence within the innovation process. User led innovation is established as a theoretically useful and coherently defined mode of innovation, distinct from the lead user or open innovation paradigms. The major contribution of the thesis is an integrated model of healthcare technology systems that emphasises the role of protoinstitutions as critical products of user-led innovation. The thesis concludes that in order to maximise the benefit of user-led innovation in the NHS, innovation policy and practice should be broadened to recognise the role of proto-institutions as a valuable product of user-led innovation

An interactive semantics of logic programming

We apply to logic programming some recently emerging ideas from the field of reduction-based communicating systems, with the aim of giving evidence of the hidden interactions and the coordination mechanisms that rule the operational machinery of such a programming paradigm. The semantic framework we have chosen for presenting our results is tile logic, which has the advantage of allowing a uniform treatment of goals and observations and of applying abstract categorical tools for proving the results. As main contributions, we mention the finitary presentation of abstract unification, and a concurrent and coordinated abstract semantics consistent with the most common semantics of logic programming. Moreover, the compositionality of the tile semantics is guaranteed by standard results, as it reduces to check that the tile systems associated to logic programs enjoy the tile decomposition property. An extension of the approach for handling constraint systems is also discussed.Comment: 42 pages, 24 figure, 3 tables, to appear in the CUP journal of Theory and Practice of Logic Programmin

Disruption management

The main objective of this project is to model the ARP (Aircraft Recovery Problem) from a constraint programming (CP) point of view. The information required for this project is extracted from previous papers that cope with the problem using heuristics, metaheuristics or using network-models. Also, two scenarios will be tested to verify that the implementation is correct

A New Method for Fuzzy Critical Path Analysis in Project Networks with a New Representation of Triangular Fuzzy Numbers

The method for finding fuzzy optimal solution of fully fuzzy critical path (FFCP) problems i.e., critical path problems in which all the parameters are represented by fuzzy numbers, is at best scant; possibly non-existent. In this paper, a method is proposed to find the fuzzy optimal solution of FFCP problems, together with a new representation of triangular fuzzy numbers. This paper will show the advantages of using, the proposed representation over the existing representations of triangular fuzzy numbers and will present with great clarity the proposed method and illustrate its application to FFCP problems occurring in real life situations

Penerapan Algoritma Genetika untuk Sistem Penjadawalan Kuliah

Timetables problems arise because of some work done simultaneously, while its resources are limited, a scheduling problem can occur in scheduling sporting events, programs converensi, scheduling in educational institutions, the scheduling of railways, as well as the scheduling of the colleges that have complexity a very big problem that arises because the number of students, faculty and lecture meetings that should be done at the same time very much but constrained in the limited space and time. This resulted in a clash in the classroom, faculty, and students. Completion of this problem requires techniques and computational methods for optimum results. This study proposes a method for the genetic algorithm timetable system at the university. a case study conducted at the faculty of computer science, University of Al Asyariah Mandar. System testing has been done by combining hard and soft constraint constraint resulted in scheduling courses are created automatically and solutions that do not conflict with the schedule of preparation time schedule relatively faster. Scheduling information system can developet with web-based applications and other optimization methods

Local consistency for extended CSPs

AbstractWe extend the framework of Constraint Satisfaction Problems to make it more suitable for/applicable to modern constraint programming languages where both constraint satisfaction and constraint solving have a role. Some rough principles for local consistency conditions in the extended framework are developed, appropriate notions of local consistency are formulated, and relationships between the various consistency conditions are established

Analysis of nonlinear constraints in CLP(R)

Solving nonlinear constraints over real numbers is a complex problem. Hence constraint logic programming languages like CLP(R) or Prolog III solve only linear constraints and delay nonlinear constraints until they become linear. This efficient implementation method has the disadvantage that sometimes computed answers are unsatisfiable or infinite loops occur due to the unsatisfiability of delayed nonlinear constraints. These problems could be solved by using a more powerful constraint solver which can deal with nonlinear constraints like in RISC-CLP(Real). Since such powerful constraint solvers are not very efficient, we propose a compromise between these two extremes. We characterize a class of CLP(R) programs for which all delayed nonlinear constraints become linear at run time. Programs belonging to this class can be safely executed with the efficient CLP(R) method while the remaining programs need a more powerful constraint solver