$\lambda$Prolog is knownto be well-suited for expressing and implementing logics andinference systems. We show that lemmas and definitions in suchlogics can be implemented with a great economy of expression. Weencode a higher-order logic using an encoding that maps both termsand types of the object logic (higher-order logic) to terms of themetalanguage ($\lambda$Prolog). We discuss both the Terzo andTeyjus implementations of $\lambda$Prolog. We also encode the same logicin Twelf and compare the features of these two metalanguages for ourpurposes.

How to extract negative information from programs is an importantissue in logic programming. Here we address the problem forfunctional logic programs, from a proof-theoretic perspective. Thestarting point of our work is CRWL (Constructorbased ReWriting Logic), a well established theoretical framework forfunctional logic programming, whose fundamental notion is that ofnon-strict non-deterministic function. We present a proof calculus,CRWLF, which is able to deduce negativeinformation from CRWL-programs. In particular,CRWLF is able to prove ‘finite’ failure ofreduction within CRWL.

In this paper, we propose a variant of stable model semantics fordisjunctive logic programming and deductive databases. Thesemantics, called minimal founded, generalizesstable model semantics for normal (i.e. non-disjunctive) programs,but differs from disjunctive stable model semantics (the extensionof stable model semantics for disjunctive programs). Compared withdisjunctive stable model semantics, minimal founded semantics seemsto be more intuitive, it gives meaning to programs which aremeaningless under stable model semantics and is no harder tocompute. More specifically, minimal founded semantics differs fromstable model semantics only for disjunctive programs havingconstraint rules or rules working as constraints. We study theexpressive power of the semantics, and show that for generaldisjunctive datalog programs it has the same power as disjunctivestable model semantics.

The work reported here introduces Defeasible Logic Programming(DeLP), a formalism that combines results of Logic Programming andDefeasible Argumentation. DeLP provides the possibility ofrepresenting information in the form of weak rulesin a declarative manner, and a defeasible argumentation inferencemechanism for warranting the entailed conclusions. In DeLP anargumentation formalism will be used for deciding betweencontradictory goals. Queries will be supported by arguments thatcould be defeated by other arguments. A query $q$ will succeed when there is anargument ${\mathcal A}$for $q$ that iswarranted, i.e. the argument ${\mathcalA}$ that supports $q$ is found undefeated by a warrant procedurethat implements a dialectical analysis. The defeasible argumentationbasis of DeLP allows to build applications that deal with incompleteand contradictory information in dynamic domains. Thus, theresulting approach is suitable for representing agent's knowledgeand for providing an argumentation based reasoning mechanism toagents.

The so called “cogen approach” to programspecialisation, writing a compiler generator instead of aspecialiser, has been used with considerable success in partialevaluation of both functional and imperative languages. This paperdemonstrates that the cogen approach is alsoapplicable to the specialisation of logic programs (called partialdeduction) and leads to effective specialisers. Moreover, using goodbinding-time annotations, the speed-ups of the specialised programsare comparable to the speed-ups obtained with online specialisers.The paper first develops a generic approach to offline partialdeduction and then a specific offline partial deduction method,leading to the offline system LIX for pure logic programs.While this is a usable specialiser by itself, it is used to developthe cogen system LOGEN. Given a program, aspecification of what inputs will be static, and an annotationspecifying which calls should be unfolded, LOGEN generatesa specialised specialiser for the program at hand. Running thisspecialiser with particular values for the static inputs results inthe specialised program. While this requires two steps instead ofone, the efficiency of the specialisation process is improved insituations where the same program is specialised multiple times. Thepaper also presents and evaluates an automatic binding-time analysisthat is able to derive the annotations. While the derivedannotations are still suboptimal compared to hand-crafted ones, theyenable non-expert users to use the LOGEN system in a fullyautomated way. Finally, LOGEN is extended so as to directlysupport a large part of Prolog's declarative and non-declarativefeatures and so as to be able to perform so called mixlinespecialisations.

We study algorithms for computing stable models of logic programs andderive estimates on their worst-case performance that areasymptotically better than the trivial bound of $O(m 2^n)$, where $m$ is the size of an input programand $n$ is the numberof its atoms. For instance, for programs whose clauses consist of atmost two literals (counting the head) we design an algorithm tocompute stable models that works in time $O(m\times 1.44225^n)$. We present similarresults for several broader classes of programs. Finally, we studythe applicability of the techniques developed in the paper to theanalysis of the performance of smodels.