This paper describes a language that is intended to support software engineers in the development of information systems throughout the software lifecycle. This language is not a programming language. Following the example of a number of other software engineering projects, our work is based on the premise that information system development is knowledge-intensive and that the primary responsibility of any language intended to support this task is to be able to formally represent the relevant knowledge.

: We propose a metalogic programming method for efficient induction of a fairly large class of list-handling logic programs delineated through restrictions on the hypothesis language. These restrictions take the form of predefined program recursion schemes (higher order "clich'es") from which the hypotheses programs in the induction process are derived by plugging in either simple, nonrecursive clause programs or invented predicates. Metalogic programming is applied for handling clauses as first class data objects in connection with program schemes, and moreover for obtaining a flexible control scheme during the induction, avoiding a blindfold generate-and-test against the given program examples. A metalogic program induction testbed has been constructed and has successfully been applied to some induction problems discussed in the literature. Keywords: Induction of logic programs, metalogic programming, higher order program clich'es, predicate invention, mixed bottom-up and top-down i...

LogicWeb is a client-side logic programming tool for the World Wide Web, which allows the Web to be viewed in a more abstract way: Web pages can be rephrased as logic programming modules, and hypertext links as relationships between the modules. This abstraction makes LogicWeb particularly suitable for coding important classes of applications, and this paper considers two in some detail: Web search, and the structuring of Web information using deductive databases. LogicWeb illustrates that logic programming possesses many advantages for writing Web applications, including the simple representation of information (e.g. as deductive databases or as logic grammars), the ability to write meta-level descriptions (e.g. of pages and the connections between pages), and the encoding of rules and heuristics necessary for "intelligent" behaviour. 1 Introduction The World Wide Web's popularity derives from its support for the global publication of pages which contain graphics, sound, animations...

The significance of any system of explicit representation depends not only on the immediate properties of its representational structures, but also on two aspects of the attendant circumstances: implicit relations among, and processes defined over, those individual representations, and larger circumstances in the world in which the whole representational system is embedded. This relativity of representation to circumstance facilitates local inference, and enables representation to connect with action, but it also limits expressive power, blocks generalisation, and inhibits communication. Thus there seems to be an inherent tension between the effectiveness of located action and the detachment of general-purpose reasoning. It is argued that various mechanisms of causally-connected self-reference enable a system to transcend the apparent tension, and partially escape the confines of circumstantial relativity. As well as examining self-reference in general, the paper shows how a variety of particular self-referential mechanisms-- autonymy, introspection, and reflection- provide the means to overcome specific kinds of implicit relativity. These mechanisms are based on distinct notions of self: self as unity, self as complex system, self as independent agent. Their power derives from their ability to render explicit what would otherwise be implicit, and implicit what would otherwise be explicit, all the while maintaining causal connection between the two. Without this causal connection, a system would either be inexorably parochial, or else remain entirely disconnected from its subject matter. When appropriately connected, however, a self-referential system can move plastically back and forth between local effectiveness and detached generality.

Annotated constraint logic programming (ACLP) combines constraint logic programming (CLP) and generalized annotated programming (GAP). With ACL we propose a first order logic with constraints where formulas can be annotated. ACL comes with inference rules for annotated formulas and a constraint theory for handling annotations. We describe an implementation based on the standard interpreter for logic programs. The inference rules of ACL are turned into clauses of the interpreter, and the constraints on annotations are solved by a suitable constraint solver. Then we optimize the interpreter. We also introduce an instance of ACLP for reasoning about time. Temporal ACLP is conceptually simple while covering substantial parts of temporal logic. Temporal annotations avoid the proliferation of variables and quantifiers of standard first-order approaches. In TACLP, the model of time can be freely chosen since it is represented in the constraint theory. Both qualitative and quantitative (metric...

We present an application of metaprogramming in logic that, unlike most metaprogramming applications, is not primarily concerned with controlling the execution of logic programs. Metalevel computation is used to define theories from schemata that were either given explicitly or obtained by abstraction from other theories. Our main application is a representation of legal knowledge in a metalogic programming language. We argue that legal knowledge is multilayered and therefore a single level representation language lacks the needed expressiveness. We show that legal rules can be partitioned into primary, secondary, tertiary, quaternary, and higher level rules. Our classification enables us to define a multilevel model of legal knowledge and a one-to-one correspondence with levels of metaprogramming in logic. We show that this framework has a potential for capturing important legal interpretation principles such as analogia legis, lex specialis Zegi generuli derogut, etc. We have a running example from commercial law that utilizes rules up to the tertiary level, emphasizing unulogiu legis. The example is expressed in a multilevel metalogic programming language that provides a naming convention and employs reflection between levels.

A widely used property of Prolog is that it is possible to write Prolog programs to construct and manipulate other Prolog programs in a very general manner. Unfortunately, this property is not carried over to richer languages such as CLP(R) -- the manipulation of CLP(R) programs in CLP(R) is quite limited. The reason is that the equality of terms in CLP(R) is not based on their syntactic structure. We propose an extended language, CLP(R+M), in which programs may be represented and structurally manipulated. Importantly, CLP(R+M) is not just a meta-language for CLP(R), but it can also be used as its own meta-language. We present a decision algorithm for R+M constraints, discuss implementation issues, and describe the implementation of a sublass of R+M constraints. Finally, by building on the extended language, we present an integrated set of system predicates and a methodology for practical meta-programming. An earlier version of this paper appeared in the Proceedings of the N...

In this paper, we introduce logical reflection as a principled way to empower the representation and reasoning capabilities of logic programming systems. In particular, reflection principles take the role of axiom schemata of a particular form that, once added to a given logic program (the basic theory, or the initial axioms), enlarge the set of consequences sanctioned by those initial axioms. The main advantage of this approach is that it is much easier to write a basic theory and then to augment it with condensed axiom schemata, than it is to write a corresponding large (or even infinite) set of axioms in the first place. Moreover, the well-established semantic properties of Horn clauses, carry over to Horn clauses with reflection. In fact, the semantics of Reflective SLD Resolution and the semantics of the Reflective Least Herbrand Model are obtained by making slight variations to, respectively, the procedural and the declarative semantics classically defined for Horn clauses. We pr...

Miller has shown that disjunctions are not necessary in a large fragment of hereditary Harrop formulae, a class of formulae which properly includes Horn clauses. In this paper we extend this result to include existential quantifications, so that for each program D, there is a program D 0 which is operationally equivalent, but contains no disjunctions or existential quantifications. We may think of this process as deriving a normal form for the program. This process is carried out by pushing the connectives outwards from the body of a clause, and this process leads to a normal form for goals as well. The properties of the search process used to find uniform proofs of goals (which generalises SLD-resolution) together with the normal form allow successful goals to be converted into program clauses, and so we may add successful goals to the program. The stored form of the goal requires a larger class of formulae, i.e. full first-order hereditary Harrop formulae, and so this lea...

Logic programming is a programming paradigm with potential to contribute to software engineering. This paper is concerned with one dimension of that potential, the impact that experience with developing logic programs can have on software design. We present a logic programming perspective on programming patterns, systematic program development, design for provability, and the paradigm of meta-programming. 1 . Abstractions help in developing complex software The essential challenge of software engineering is how to build and maintain complex software. The challenge has continued unabated over many years. Computer use is increasing, and with increased computer use has come increased user knowledge, and rising expectations of software reliability and usability. Opinions vary as to whether current software engineering practice can meet expectations. Harel (1992) sounded an optimistic tune. While acknowledging earlier cautionary writing of Brooks (1987) and Parnas (1985) that there is no ...