Gaetano Aurelio Lanzarone

A metalogic programming approach: language, semantics and applications

Abstract This paper presents a logic programming language of novel conception, called Reflective Prolog, which allows declarative metaknowledge representation and metareasoning. The language is defined by augmenting pure Prolog (Horn clauses) with capabilities of self-reference and logical reflection. Self-reference is designed as a quotation device (a carefully defined naming relation) which allows the construction of metalevel terms that refer to object-level terms and atoms. Logical reflection is designed as an unquotation mechanism (a distinguished truth predicate) which relates names to what is named, thus extending the meaning of domain predicates. The reflection mechanism is embodied in an extended resolution procedure which automatically switches the context between levels. This implicit reflection relieves the programmer from having to explicitly deal with control aspects of the inference process. The declarative semantics of a Reflective Prolog definite program P is provided in terms of the leas...

Reflective Agents in Metalogic Programming

We introduce a representation of agents by means of theories, and a communication among agents based on reflection, within the metalogic programming paradigm. The semantics of these features is shown to be the classical semantics of Horn clauses. The primitives for agents representation and inter-agent communication are very simple, and non-committal w.r.t. any predefined cognitive model or linguistic modality. Yet, it is shown by means of examples that they have enough expressive power for reasoning in non-trivial multi-agent domains, like the three wise men problem, especially when embedded in a powerful language, such as Reflective Prolog that we have previously developed. By integrating agents into Reflective Prolog we get a metalogic language equipped with higher-order-like features, metalevel negation, and theories, all of which rely on logical reflection for a uniform semantics and support each other for greater expressive and problem-solving power.

A formal definition and a sound implementation of analogical reasoning in logic programming

A formal model of analogy is introduced in the logic programming setting, and an analogical reasoning program (called DIANA, i.e. Declarative Inference by ANAlogy) is developed in accordance with precise procedural and declarative semantics. Given the source and target domains of analogy as two logic programsPs andPt, together with a specificationS of the analogical correspondence between predicate symbols, atoms involving these symbols are analogically derived fromP=Ps ∪Pt givenS, which are not derivable fromPs orPt orPs ∪Pt alone. In this paper, the requirements of the analogical process are first stated. The declarative semantics of analogy is then given, by defining the least analogical model ofP as an extension of the classical semantics of Horn clauses. A procedural semantics is also described, in terms of an extension of SLD resolution. Both semantics rely on implicit analogical axioms defining the kind of analogical reasoning envisaged. The implementation of DIANA has been done in Reflective Prolog, a metalogic programming language previously developed by the first two authors. It is shown that analogical axioms can be viewed as an instance of reflection axioms used in Reflective Prolog. By exploiting this feature, the implementation of DIANA is argued to be sound w.r.t. the defined semantics. Examples of analogical reasoning in DIANA are also described. By comparison with the AI literature on analogy, it is claimed that this is the first approach which gives a declarative semantics to analogical reasoning, thanks to the possibility of carrying over in this field the basic logic programming concepts.

Static Semantics as Program Transformation and Well-founded Computation

In this paper, we propose a new constructive characterization of those semantics for disjunctive logic programs which are extensions of the well-founded semantics for normal programs. Based on considerations about how disjunctive information is treated by a given semantics, we divide the computation of that semantics into two phases. The first one is a program transformation phase, which applies axiom schemata expressing how derivations involving disjunctions are made in the given semantic framework. The second one is a constructive phase, based on a variation of the well-founded model construction for normal programs. We apply this two-phases procedural semantics to the computation of the static semantics of disjunctive logic programs as a case-study, showing how it works and what its results are in several examples. A main perspective of this proposal is a procedural semantics for disjunctive programs consisting of an inefficient preprocessing phase (implementing the program transformation procedure), to be however performed only once, and of an efficient runtime computation, obtained as a variation of any effective procedural semantics for the well-founded model.

Metareasoning agents for query-answering systems

In this paper we claim, and demonstrate by means of a number of examples, that a formalism equipped with metalogic and reflection capabilities allows us to easily model (by means of the metalevel) and implement (by means of reflection) the desired degree of flexibility in a query-answering system interacting with a data/knowledge base. We also try to show that a main feature of building a really flexible system is the possibility of modeling metalogical agents, which are able to interact and to communicate in various different ways. This because it is useful to view a query-answering system as a collection of agents including, in particular, some external (typically human) agents, in order to make a system behave more rationally and flexibly towards users.

Explanation-based interpretation of open-textured concepts in logical models of legislation

In this paper we discuss a view of the Machine Learning technique called Explanation-Based Learning (EBL) or Explanation-Based Generalization (EBG) as a process for the interpretation of vague concepts in logic-based models of law.The open-textured nature of legal terms is a well-known open problem in the building of knowledge-based legal systems. EBG is a technique which creates generalizations of given examples on the basis of background domain knowledge. We relate these two topics by considering EBGs domain knowledge as corresponding to statute law rules, and EBGs training example as corresponding to a precedent case.By making the interpretation of vague predicates as guided by precedent cases, we use EBG as an effective process capable of creating a link between predicates appearing as open-textured concepts in law rules, and predicates appearing as ordinary language wording for stating the facts of a case.Standard EBG algorithms do not change the deductive closure of the domain theory. In the legal context, this is only adequate when concepts vaguely defined in some law rules can be reformulated in terms of other concepts more precisely defined in other rules. We call ‘theory reformulation’ the process adopted in this situation of ‘complete knowledge’.In many cases, however, statutory law leaves some concepts completely undefined. We then propose extensions to the EBG standard that deal with this situation of ‘incomplete knowledge’, and call ‘theory revision’ the extended process. In order to fill in ‘knowledge gaps’ we consider precedent cases supplemented by additional heuristic information. The extensions proposed treat heuristics represented by abstraction hierarchies with constraints and exceptions.In the paper we also precisely characterize the distinction between theory reformulation and theory revision by stating formal definitions and results, in the context of the Logic Programming theory.We offer this proposal as a possible contribution to cross fertilization between machine learning and legal reasoning methods.

Extending Horn Clause Theories by Reflection Principles

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 present a complete formalization of this concept of reflection, that should constitute a simple way of understanding reflective programs; and a description of how reflection allows one to treat uniformly different application areas. To support this claim, the following three case studies will be discussed: metalevel reasoning; reasoning with multiple communicating theories (agents); and analogical reasoning. For each of these areas, the choice of a suitable reflection principle is shown, which tries to capture the specificity of the problem domain.

Guidelines on using net analysis techniques with large specifications

First steps towards methods really applicable to deal with large specifications of real-life systems are offered in this paper.

Experiments in Answer Sets Planning

The study of formal nonmonotonic reasoning has been motivated to a large degree by the need to solve the frame problem and other problems related to representing actions. New efficient implementations of nonmonotonic reasoning, such as SMODELS and DLV, can be used to solve many computational problems that involve actions, including plan generation. SMODELS and its competitors are essential to implement a new approach to knowledge representation and reasoning: to compute solutions to a problem by computing the stable models (answer sets) of the theory that represents it. Marek and Truszczynski call this paradigm Stable model programming. We are trying to assess the viability of stable logic programming for agent specification and planning in realistic scenarios. To do so, we present an encoding of plan generation within the lines of Lifschitz’s Answer set planning and evaluate its performance in the simple scenario of Blocks world. Several optimization techniques stemming from mainstream as well as satisfiability planning are added to our planner, and their impact is discussed.