Browsing by Author "Cleary, John"

Now showing 1 - 18 of 18
  • Thumbnail Image
    ItemOpen Access
    Communicating Sequential Prolog
    (1988-01-01) Li, Xining; Unger, Brian W; Cleary, John; Lomow, Greg; West, Darrin
    Communicating Sequential Prolog (CSP') is a single-solution distributed logic programming language for discrete event simulation. Its primary goal is to speed up the execution of logic programs through the use of parallelism, while as far as possible preserving the semantics of standard Prolog. A CSP' program consists of a set of parallel processes, synchronized by simulation time and by message passing. The underlying interprocess communication mechanism is Time Warp. The pertinent features of parallel logic programming and Time Warp are described. The syntax of CSP' is introduced and the semantics of new predicates and their control structures are discussed. Examples are given to show the expressive power and simplicity of CSP'.
  • Thumbnail Image
    ItemOpen Access
    DECLARATIVE UPDATES IN DEDUCTIVE DATABASES
    (1993-01-01) Cleary, John; Liu, Mengchi
    This paper proposes an update language called Datalog/UT which extends Datalog by incorporating update rules with temporal information. Programs to update example Databases are given. The semantics of Datalog/UT are described. Datalog/UT has a declarative semantics using local stratification which is a natural and direct extension of the traditional Datalog semantics and reduces to it in the special case. This is achieved by using explicit temporal information to control the update operations implicitly.
  • Thumbnail Image
    ItemOpen Access
    DECLARATIVE UPDATES IN DEDUCTIVE OBJECT BASES
    (1993-03-01) Cleary, John; Liu, Mengchi
    Updates are important database operations, but there has not yet been a uniform logical framework that accounts for them. This paper presents an approach to deal with updates in the deductive and object-oriented database setting. It incorporates temporal information into update rules, so that different versions of objects may be created at different time points and can be identified by the temporal information. The proposed update language has a simple and clear Herbrand-like declarative semantics, which can be computed by a bottom-up evaluation using a temporal stratification.
  • Thumbnail Image
    ItemOpen Access
    DEDUCTIVE DATABASES - WHERE TO NOW?
    (1990-01-01) Cleary, John; Liu, Mengchi
    Deductive databases result from the integration of relational database and logic programming techniques. It combines the benefits of these two approaches, such as representational and operational uniformity, deductive power, efficient secondary storage access, etc. However, significant problems remain inherent in this synthesis. There are three broad areas where problems are apparent. The first problem area is how to naturally represent objects, complex objects and inheritance information. The second problem area is how to naturally deal with higher-order features in deductive databases. The last is the area of updates. The paper discusses these problems, surveys some of the attempts that have been made towards solving these problems and prepares an integrated framework for solving them.
  • No Thumbnail Available
    ItemMetadata only
    Discrete event simulation in prolog
    (1984-11-01) Cleary, John; Goh, Kim-Siew; Unger, Brian W
    A logic programming language for simulation is presented along with several examples of its use. This language uses the same primitives as Concurrent Prolog with the addition of delay expressions in the guards. An advantage of this approach is that Concurrent Prolog programs can be prototyped and debugged via simulation after which the delay expressions can be ignored to produce the final Concurrent Prolog program. Limited backtracking is supported in the initial language interpreter which is written in standard Prolog. This enables alternate paths in a simulation to be explored for acceptable solutions. As in Concurrent Prolog a declarative interpretation of a program is possible. That is, a Concurrent Prolog program can be considered as a set of axioms in first order logic.
  • Thumbnail Image
    ItemOpen Access
    A distributed and parallel backtracking algorithm using virtual time
    (1987-10-01) Cleary, John; Unger, Brian W; Li, Xining
    A significant problem in Logic Programming is how to execute Prolog on multiprocessor and distributed systems. For and-parallel Prolog correctly co-ordinating backtracking across many processors is difficult. An algorithm which fully supports such backtracking is described. The algorithm is based on the Virtual Time technique first described by Jefferson and Sowizral in their Time Warp system for concurrent discrete event simulation. The algorithm preserves the standard semantics of Prolog and does not require additional program control other than directives as to where goals should be run. Because of the logical semantics of Prolog optimizations of the basic Time Warp algorithm are possible. These reduce the number of rollbacks necessary and the amount of recomputation necessary after a rollback.
  • Thumbnail Image
    ItemOpen Access
    A distributed software prototyping and simulation environment: JADE
    (1985-10-01) Unger, Brian W; Dewar, Alan; Cleary, John; Birtwistle, Graham
    Jade is an environment that supports the development of distributed software. Components may be written in any of a number of different languages. A common inter-process communication protocol provides a uniform interface among the components. A window system allows the user to interact with many different processes at once. A hierarchical graphics system is provided for use with documentation and programming, and for support of monitoring. Monitoring in Jade is also supported by an extensible mechanism which allows for multiple views of the same process. The non- determinism of distributed systems may be controlled in order to provide repeatability of executions and to aid in testing and debugging. Finally, the formal specification of inter-process events in Jade is supported by a communications protocol verifier, allowing run-time consistency checking. Together, these tools provide a powerful environment for software prototyping and simulation.
  • No Thumbnail Available
    ItemMetadata only
    INTERPRETERS IN LOGIC PROGRAMMING: A POWERFUL TOOL FOR SIMULATION
    (1983-11-01) Cleary, John; Dewar, Alan
    The logic programming language Prolog and extensions to permit asynchronous execution are introduced. Some simple producer/consumer problems are used to illustrate the handling of processes and their synchronization. Some tools that can be used to aid tracing and verifying such programs are described. These include a system that will check whether one version of a program is a refinement of another, and another that allows simple and flexible programming of graphical displays of data structures and executing programs. These are used as examples to support the assertion that logic programming provides very powerful tools for verifying the correctness of simulations and programs.
  • Thumbnail Image
    ItemOpen Access
    The JADE approach to distributed software development
    (1985-11-01) Unger, Brian W; Dewar, Alan; Cleary, John; Birtwistle, Graham
    Jade is an environment that supports the development of distributed software. Components may be written in any of a number of different languages. A common inter-process communication protocol provides a uniform interface among the components. A window system allows the user to interact with many different processes at once and allows for multiple views of the same process. A hierarchical graphics system is provided for use with documentation and programming, and for support of monitoring. The non-determination of distributed systems may be controlled in order to provide repeatability of executions and to aid in prototyping real-time distributed software. Finally, the formal specification of inter-process events in Jade is supported by a communications protocol verifier, allowing run-time consistency checking. We describe these tools and their use in the development of distributed software for the control of a simulated system of parking lots.
  • Thumbnail Image
    ItemOpen Access
    JADE virtual time implementation manual
    (1986-09-01) Unger, Brian W; Cleary, John; Lomow, Greg; Xining, Li; Zhonge, Xiao; Slind, Konrad
    No Abstract
  • No Thumbnail Available
    ItemMetadata only
    JADE: a distributed software prototyping environment
    (1983-04-01) Witten, Ian H.; Birtwistle, Graham M.; Cleary, John; Hill, David R.; Levinson, Danny; Lomow, Greg; Neal, Radford; Peterson, Murray; Unger, Brian W; Wyvill, Brian
    The Jade research project is aimed at building an environment which comfortably supports the design, construction, and testing of distributed computer systems. This note is an informal project description which delimits the scope of the work and identifies the research problems which are tackled. Some design issues are discussed, and progress to date is described.
  • No Thumbnail Available
    ItemMetadata only
    JADE: a simulation & software prototyping environment
    (1983-11-01) Unger, Brian W; Birtwistle, Graham; Cleary, John; Hill, David; Lomow, Greg; Neal, Radford; Peterson, Murray; Witten, Ian; Wyvill, Brian
    Jade provides an integrated set of tools which are designed to support the development of distributed software and systems. The Jade environment provides tools for the design, implementation, debugging, testing, maintenance, and performance analysis of distributed, concurrent programs. Novel features of Jade are that it is based on the modelling and simulation of target distributed systems and partially automatic program generation is supported. The goals of Jade are to provide a cost effective software development environment that is both easy and comfortable to use, and which can produce more reliable, maintainable programs. This paper presents an overview of the Jade environment, describes its major components, and outlines the status of the project.
  • No Thumbnail Available
    ItemMetadata only
    PERSONALIZABLE DIRECTORIES: A CASE STUDY IN AUTOMATIC USER MODELLING
    (1983-03-01) Witten, Ian H.; Greenberg, Saul; Cleary, John
    A personalized directory system is presented which demonstrates how automatic user modelling can reduce the average number of menu-based selections needed to retrieve entries from a large ordered list, such as a telephone directory. It offers a simple case study for pilot human factor experiments in automatic user modelling; it affords the possibility of a device independent menu-selection system; in automatic user modelling are raised, such as the user's perception of a dynamic system, the need of user control and the measurement of user satisfaction. The personalized directory system is being used as a test-bed to examine such issues, and will refine our insight into the human factors implications of user modelling.
  • Thumbnail Image
    ItemOpen Access
    RAY TRACING IN CALGARY AND OTAGO
    (1987-03-01) Wyvill, Geoff; Wyvill, Brian; Cleary, John
    No abstract
  • No Thumbnail Available
    ItemOpen Access
    Rule trees an execution mechanism for time-ordered forward deduction evaluating strategy of Starlog
    (1998-07-01) Xiao, Zhonge; Cleary, John; Unger, Brian W
    This is the second report on "Time-ordered Forward Deduction" algorithm for Starlog. A \fBRule Tree (R-tree)\fR structure is discussed. The R-tree is used to represent a program rule in the dynamic process of program execution. It serves not only as a structured data storage for program rules and their derivable instances, but also as a control structure in program execution which allows the execution to be carried out in more orderly and formal manner.
  • Thumbnail Image
    ItemOpen Access
    S-LOGIC: A HIGHER-ORDER LOGIC LANGUAGE FOR DEDUCTIVE DATABASES
    (1990-02-01) Cleary, John; Liu, Mengchi
    Deductive databases based on relational databases and Prolog techniques are not suitable for complex object modeling. The problems result from the underlying relational model and the pure Prolog which use inexpressive flat structures. Semantic data models using data abstractions and inheritance greatly increase expressiveness. So do extended terms with internal structure in logic programming. This paper proposes a higher-order logic language for deductive databases called S-logic which is the combination of the semantic data model and extended term approaches. It supports object identity, semantic data abstractions and inheritance very naturally and allows the definition and manipulation of database schema and data in an integrated framework.
  • No Thumbnail Available
    ItemOpen Access
    Time-ordered forward deduction a bottom-up evaluation strategy for Starlog
    (1998-07-01) Xiao, Zhonge; Cleary, John; Unger, Brian W
    Starlog, a Horn clause logic programming language, allows for time stamps, interval arithmetic, and negations. A bottom-up evaluation strategy, called "Time-ordered Forward Deduction", for the language is described. The algorithm heavily relies on time stratification as its basic execution control mechanism. A conservative approach has been adopted to handle negations, which defers the evaluation of negations until it is safe to do so. Various techniques to deal with subtle cases of inter-clause relations in negation evaluation are discussed. To illustrate the algorithm, some simple but non-trivial example programs are presented.
  • No Thumbnail Available
    ItemOpen Access
    Time-ordered forward deduction with negation evaluation strategy revised
    (1998-07-01) Xiao, Zhonge; Cleary, John; Unger, Brian W
    This is the third report on "Time-ordered Forward Deduction" algorithm for Starlog. The negation evaluation part of the algorithm has been modified extensively based on experiments with previous implementations and further study. The new algorithm is optimistic in terms of its negation evaluation strategy. The notion of \fBOpen Tuple\fR and related \fBNegation Failure Bound Splitting (NFBS)\fR method are introduced. A complete definition of the new algorithm is given, it treats the execution of a program in a more consistent and uniform manner and does not involve any semantic aspects of a program. It is our belief that a formal proof of the algorithm is not too difficult.