Search

• The copy complexity of a Horn formula equals the copy complexity of the corresponding system of constraints. • The copy complexity of Horn formulas with respect to unit resolution is (m − 1) when copies of derived clauses are allowed. • A polynomial time algorithm that can determine if a 2-CNF formula has a unit read-once resolution refutation. In this paper, we discuss the copy complexity of Horn formulas with respect to unit resolution. A Horn formula is a boolean formula in conjunctive normal form (CNF) with at most one positive literal per clause. Horn formulas find applications in a number of domains, such as program verification (abstract interpretation) and logic programming (answer set programming). Quantified Horn clauses are used extensively in temporal verification of universal properties. Resolution is one of the oldest proof systems (refutation systems) for the boolean satisfiability problem (SAT), when the input is presented in conjunctive normal form (CNF). It is both sound and complete, although inefficient, when compared to other stronger proof systems for boolean formulas. Despite its inefficiency, the simple nature of resolution makes it an integral part of several theorem provers. Unit resolution is a restricted form of resolution in which each resolution step needs to use a clause with only one literal (unit literal clause). While not complete for general CNF formulas, unit resolution is complete for Horn formulas. Read-once resolution is a form of resolution in which each clause (input or derived) may be used in at most one resolution step. As with unit resolution, read-once resolution is incomplete in general and complete for Horn clauses. This paper focuses on a combination of unit resolution and read-once resolution called unit read-once resolution. Unit read-once resolution is incomplete for Horn clauses. In this paper, we study the copy complexity problem in Horn formulas with respect to unit read-once resolution. Briefly, the copy complexity of a formula with respect to unit read-once resolution, is the smallest number k , such that replicating each clause k times guarantees the existence of a unit read-once resolution refutation (UROR). This paper focuses on two problems related to the copy complexity of Horn formulas with respect to unit read-once resolution. We first relate the copy complexity of Horn formulas with respect to unit read-once resolution to the copy complexity of the corresponding Horn constraint system with respect to the addition rule. We also examine a form of copy complexity in which we permit replication of derived clauses, in addition to the input clauses. Finally, we provide a polynomial time algorithm for the problem of checking if a 2-CNF formula has a UROR. [ABSTRACT FROM AUTHOR]

Reaction Systems (RSs) are a successful computational framework inspired by biological systems. A RS pairs a set of entities with a set of reactions over them. Entities can be used to enable or inhibit each reaction, and are produced by reactions. Entities can also be provided by an external context sequence to simulate in silico biological experiments. In this paper we define an extension of RSs considering nondeterministic and recursive context operators, and give an original labelled transition system (LTS) for extended RSs in the structural operational semantics (SOS) style. Thanks to extended contexts, a single LTS can now account for several biological experiments. The rich information recorded in transition labels is useful to guarantee the compositionality of SOS inference rules as well as to define an assertion language to tailor behavioural and logical equivalences on some specific properties or entities. The SOS rules have been also exploited to design a flexible prototype implementation in logic programming that allows to inspect the LTS and to extract useful information when performing experiments on a RS. Our implementation provides a rapid prototyping tool for (extensions of) RSs, with a user friendly online interface to our interpreter. A parser allows to introduce the logical formulas and the contexts using the usual comfortable concrete syntax. The user can visualise and inspect the LTS for a RS and make some analysis of its underlying computation patterns, can check if the main RS satisfies a given property and if it is equivalent to a second adversarial RS. Finally, the SOS approach is suited to drive additional enhancements of RSs. [ABSTRACT FROM AUTHOR]

When studying sequent calculi, proof theorists often have to prove properties about the systems, whether to show that they are "well-behaved", amenable to automated proof search, complete with respect to another system, consistent, among other reasons. These proofs usually involve many very similar cases, which leads to authors rarely writing them in full detail, only pointing to one or two more complicated cases. Moreover, the amount of details makes them more error-prone for humans. Computers, on the other hand, are very good at handling details and repetitiveness. In this work we have formalized textbook proofs of the meta-theory of sequent calculi for linear logic in Abella. Using the infrastructure developed, the proofs can be easily adapted to other substructural logics. We implemented rules as clauses in an intuitive and straightforward way, similar to logic programming, using operations on multisets for the explicit contexts. Although the proofs are quite big, they use only elementary reasoning principles, which makes the proof techniques fairly portable to other formal reasoning systems. [ABSTRACT FROM AUTHOR]

We generalize the notion of "not subject to occur-check" (NSTO), on which most known results on avoiding the occur-check in logic programming are based. NSTO means that unification is performed only on such pairs of atoms for which the occur-check never succeeds in any run of a nondeterministic unification algorithm. Here we show that "any run" can be weakened to "some run". We present some related sufficient conditions under which the occur-check may be safely omitted. We show examples for which the proposed approach provides more general results than the approaches based on well-moded and nicely moded programs (this includes cases to which the latter approaches are inapplicable). We additionally present a sufficient condition based on NSTO, working for arbitrary selection rules. • We deal with sufficient conditions for avoiding the occur-check in unification. • Such conditions have been based on a notion of "not subject to occur-check" (NSTO). • We propose a less restrictive version of NSTO. • It widens the class of cases dealt with. • Also, it leads to simpler sufficient conditions than NSTO, for some cases. [ABSTRACT FROM AUTHOR]

This article studies the learnability of classes of pattern languages over automatic groups. It is shown that the class of bounded unions of pattern languages over finitely generated Abelian automatic groups is explanatorily learnable. For patterns in which variables occur at most n times, it is shown that the classes of languages generated by such patterns as well as their bounded unions are, for finitely generated automatic groups, explanatorily learnable by an automatic learner. In contrast, automatic learners cannot learn the unions of up to two arbitrary pattern languages over the integers. Furthermore, there is an algorithm which, given an automaton describing a group G , generates a learning algorithm M G such that either M G explanatorily learns all pattern languages over G or there is no learner for this set of languages at all, not even a non-recursive one. For some automatic groups, non-learnability results of natural classes of pattern languages are provided. [ABSTRACT FROM AUTHOR]

We define a Kripke semantics for Intuitionistic Higher-Order Logic with constraints formulated within Church's Theory of Types via the addition of a new constraint base type. We then define an executable fragment, hoHH ( C ) , of the logic: a higher-order logic programming language with typed λ -abstraction, implication and universal quantification in goals and constraints, and give a modified model theory for this fragment. Both formal systems are shown sound and complete for their respective semantics. We also solve the impredicativity problem in λ Prolog semantics, namely how to give a definition of truth without appealing to induction on subformula structure. In the last section we give a simple semantics-based conservative extension proof that the language hoHH ( C ) satisfies a uniformity property along the lines of [39] . [ABSTRACT FROM AUTHOR]

The present contribution advances an abstract notion of hybrid logic by supplementing the definition of institution with an additional structure to extract frames. The foundation of logic programming is set in the general framework proposed by defining the basic concepts such as Horn clause, query and solution, and proving fundamental results such as the existence of initial model of Horn clauses and Herbrand's theorem. The abstract results are then applied to hybrid logics with user-defined sharing, where the possible worlds share a common domain and the variables used for quantification are interpreted uniformly across the worlds. [ABSTRACT FROM AUTHOR]

Two distinct research approaches have been proposed for assigning extensional semantics to higher-order logic programming. The former approach [11] uses classical domain-theoretic tools while the latter [1] builds on a fixed-point construction defined on a syntactic instantiation of the source program. The relationships between these two approaches had not been investigated until now. In this paper we demonstrate that for a very broad class of programs, namely the class of definitional programs introduced by W.W. Wadge, the two approaches coincide with respect to ground atoms that involve symbols of the program. On the other hand, we argue that if existential higher-order variables are allowed to appear in the bodies of program rules, the two approaches are in general different. The results of the paper contribute to a better understanding of the semantics of higher-order logic programming. [ABSTRACT FROM AUTHOR]

Modeling, Simulation and Verification Language (MSVL) is a useful formalism for specification and verification of concurrent systems. To make it more practical and easier to use, we extend MSVL with external and internal function calls. To do so, the syntax of function definitions and function calls is formalized. Then, the syntax of expressions in MSVL is extended by including function calls. Further, the evaluation rules are redefined. Moreover, the set of statements in MSVL is also extended and the semantics of function call statements is formalized. In addition, the existence of minimal models of MSVL programs involving new added statements is proved. Finally, an example is given to illustrate how to interpret function calls in practice with MSVL. [ABSTRACT FROM AUTHOR]

We present a fixed point theorem for a class of (potentially) non-monotonic functions over specially structured complete lattices. The theorem has as a special case the Knaster–Tarski fixed point theorem when restricted to the case of monotonic functions and Kleene's theorem when the functions are additionally continuous. From the practical side, the theorem has direct applications in the semantics of negation in logic programming. In particular, it leads to a more direct and elegant proof of the least fixed point result of [12] . Moreover, the theorem appears to have potential for possible applications outside the logic programming domain. [ABSTRACT FROM AUTHOR]

Abstract: Intuitionistic logic and intuitionistic type systems are commonly used as frameworks for the specification of natural deduction proof systems. In this paper we show how to use classical linear logic as a logical framework to specify sequent calculus proof systems and to establish some simple consequences of the specified sequent calculus proof systems. In particular, derivability of an inference rule from a set of inference rules can be decided by bounded (linear) logic programming search on the specified rules. We also present two simple and decidable conditions that guarantee that the cut rule and non-atomic initial rules can be eliminated. [Copyright &y& Elsevier]

Abstract: A succinct SAT solver is presented that exploits the control provided by delay declarations to implement watched literals and unit propagation. Despite its brevity the solver is surprisingly powerful and its elegant use of Prolog constructs is presented as a programming pearl. Furthermore, the SAT solver can be integrated into an SMT framework which exploits the constraint solvers that are available in many Prolog systems. [Copyright &y& Elsevier]

Abstract: We present a generic scheme for the declarative debugging of programs that are written in rewriting-based languages that are equipped with narrowing. Our aim is to provide an integrated development environment in which it is possible to debug a program and then correct it automatically. Our methodology is based on the combination (in a single framework) of a semantics-based diagnoser that identifies those parts of the code that contain errors and an inductive learner that tries to repair them, once the bugs have been located in the program. We develop our methodology in several steps. First, we associate with our programs a semantics that is based on a (continuous) immediate consequence operator, , which models the answers computed by narrowing and is parametric w.r.t. the evaluation strategy, which can be eager or lazy. Then, we show that, given the intended specification of a program , it is possible to check the correctness of by a single step of . In order to develop an effective debugging method, we approximate the computed answers semantics of and derive a finitely terminating bottom-up abstract diagnosis method, which can be used statically. Finally, a bug-correction program synthesis methodology attempts to correct the erroneous components of the wrong code. We propose a hybrid, top-down (unfolding-based) as well as bottom-up (induction-based), correction approach that is driven by a set of evidence examples which are automatically produced as an outcome by the diagnoser. The resulting program is proven to be correct and complete w.r.t. the considered example sets. Our debugging framework does not require the user to provide error symptoms in advance or to answer difficult questions concerning program correctness. An implementation of our debugging system has been undertaken which demonstrates the workability of our approach. [ABSTRACT FROM AUTHOR]

Abstract: is a logic programming language which extends usual clauses by adding intuitionistic implication in goals and clause bodies. This extension can be seen as a way of structuring programs in logic programming. We are interested in finding correct and efficient translations from programs into some representation type that, preserving the signature, allows us suitable implementations of these kinds of programs. In this paper we restrict to the propositional setting of and we study correct translations into Boolean circuits, i.e. graphs; into Boolean formulas, i.e. trees; and into conjunctions of propositional clauses. Different results for the efficiencies of the transformations are obtained in the three cases. [Copyright &y& Elsevier]

Abstract: LMNtal (pronounced “elemental”) is a simple language model based on hierarchical graph rewriting that uses logical variables to represent connectivity and membranes to represent hierarchy. LMNtal is an outcome of the attempt to unify constraint-based concurrency and Constraint Handling Rules (CHR), the two notable extensions to concurrent logic programming. LMNtal is intended to be a substrate language of various computational models, especially those addressing concurrency, mobility and multiset rewriting. Although the principal objective of LMNtal was to provide a unifying computational model, it is of interest to equip the formalism with a precise logical interpretation. In this paper, we show that it is possible to give LMNtal a simple logical interpretation based on intuitionistic linear logic and a flattening technique. This enables us to call LMNtal a hierarchical, concurrent linear logic language. [Copyright &y& Elsevier]

Abstract: We extend the abstract interpretation point of view on context-free grammars by Cousot and Cousot to resolution-based logic programs and proof systems. Starting from a transition-based small-step operational semantics of Prolog programs (akin to the Warren Machine), we consider maximal finite derivations for the transition system from most general goals. This semantics is abstracted by instantiation to terms and furthermore to ground terms, following the so-called c- and s-semantics approach. Orthogonally, these sets of derivations can be abstracted to SLD-trees, call patterns and models, as well as interpreters providing effective implementations (such as Prolog). These semantics can be presented in bottom–up fixpoint form. This abstract interpretation-based construction leads to classical bottom–up semantics (such as the s-semantics of computed answers, the c-semantics of correct answers of Keith Clark, and the minimal-model semantics of logical consequences of Maarten van Emden and Robert Kowalski). The approach is general and can be applied to infinite and top–down semantics in a straightforward way. [Copyright &y& Elsevier]

Abstract: The current ubiquity of multi-core processors has brought renewed interest in program parallelization. Logic programs allow studying the parallelization of programs with complex, dynamic data structures with (declarative) pointers in a comparatively simple semantic setting. In this context, automatic parallelizers which exploit and-parallelism rely on notions of independence in order to ensure certain efficiency properties. “Non-strict” independence is a more relaxed notion than the traditional notion of “strict” independence which still ensures the relevant efficiency properties and can allow considerable more parallelism. Non-strict independence cannot be determined solely at run-time (“a priori”) and thus global analysis is a requirement. However, extracting non-strict independence information from available analyses and domains is non-trivial. This paper provides on one hand an extended presentation of our classic techniques for compile-time detection of non-strict independence based on extracting information from (abstract interpretation-based) analyses using the now well understood and popular Sharing Freeness domain. This includes algorithms for combined compile-time/run-time detection which involve special run-time checks for this type of parallelism. In addition, we propose herein novel annotation (parallelization) algorithms, URLP and CRLP, which are specially suited to non-strict independence. We also propose new ways of using the Sharing Freeness information to optimize how the run-time environments of goals are kept apart during parallel execution. Finally, we also describe the implementation of these techniques in our parallelizing compiler and recall some early performance results. We provide as well an extended description of our pictorial representation of sharing and freeness information. [Copyright &y& Elsevier]

Abstract: The paper provides an overview of the s-semantic approach to the semantics of logic programs which had been developed about twenty years ago. The aim of such an approach was that of providing a suitable base for program analysis by means of a semantics which really captures the operational behavior of logic programs, and thus offers useful notions of observable program equivalences. The semantics is given in terms of extended interpretations, which are more expressive than Herbrand interpretations, extends the standard Herbrand semantics, and can be obtained as a result of both top-down and bottom-up constructions. The approach has been applied to several extensions of positive logic programs and used to develop semantic-based techniques for program analysis, verification and transformation. [Copyright &y& Elsevier]

Abstract: We develop an algebraic framework, Logic Programming Doctrines, for the syntax, proof theory, operational semantics and model theory of Horn Clause logic programming based on indexed premonoidal categories. Our aim is to provide a uniform framework for logic programming and its extensions capable of incorporating constraints, abstract data types, features imported from other programming language paradigms and a mathematical description of the state space in a declarative manner. We define a new way to embed information about data into logic programming derivations by building a sketch-like description of data structures directly into an indexed category of proofs. We give an algebraic axiomatization of bottom-up semantics in this general setting, describing categorical models as fixed points of a continuous operator. [Copyright &y& Elsevier]

Abstract: The semantics of process calculi has traditionally been specified by labelled transition systems (ltss), but, with the development of name calculi, it turned out that reaction rules (i.e., unlabelled transition rules) are often more natural. This leads to the question of how behavioral equivalences (bisimilarity, trace equivalence, etc.) defined for lts can be transferred to unlabelled transition systems. Recently, in order to answer this question, several proposals have been made with the aim of automatically deriving an lts from reaction rules in such a way that the resulting equivalences are congruences. Furthermore, these equivalences should agree with the standard semantics, whenever one exists. In this paper, we propose saturated semantics, based on a weaker notion of observation and orthogonal to all the previous proposals, and we demonstrate the appropriateness of our semantics by means of two examples: logic programming and open Petri nets. We also show that saturated semantics can be efficiently characterized through the so called semi-saturated games. Finally, we provide coalgebraic models relying on presheaves. [Copyright &y& Elsevier]

Abstract: When we are concerned with the logical form of a computation and its formal properties, then it can be theoretically described in terms of mathematical and logical functions and relations between abstract entities. However, actual computation is realised by some physical process, and the latter is of course subject to physical laws and the laws of thermodynamics in particular. An issue that has been the subject of much controversy is that of whether or not there are any systematic connections between the logical properties of computations considered abstractly and the thermodynamical properties of their concrete physical realizations. Landauer [R. Landauer, Irreversibility and heat generation in the computing process, IBM Journal of Research and Development 5 (1961) 183–191. Reprinted in Leff and Rex (1990)] proposed such a general connection, known as Landauer’s Principle. To resolve this matter an analysis of the notion of the implementation of a computation by a physical system is clearly required. Another issue that calls for an analysis of implementation is that of realism about computation. The account of implementation presented here is based on the notion of an -machine. This is a hybrid physical-logical entity that combines a physical device, a specification of which physical states of that device correspond to various logical states, and an evolution of that device which corresponds to the logical transformation . The most general form of Landauer’s Principle can be precisely stated in terms of -machines, namely that the logical irreversibility of implies the thermodynamic irreversibility of every corresponding -machine. [Copyright &y& Elsevier]

Abstract: In this paper, we investigate quantum algorithms for graph colouring problems, in particular for 2- and 3-colouring of graphs. Our main goal is to establish a set of quantum representations and operations suitable for the problem at hand. We propose unitary- as well as measurement-based quantum computations, also taking inspiration from answer set programming, a form of declarative programming close to traditional logic programming. The approach used is one in which we first generate arbitrary solutions to the problem, then constraining these according to the problem’s input. Though we do not achieve fundamental speed-ups, our algorithms show how quantum concepts can be used for programming and moreover exhibit structural differences. For example, we compute all possible colourings at the same time. We compare our algorithms with classical ones, highlighting how the same type of difficulties give rise to NP-complete behaviour, and propose possible improvements. [Copyright &y& Elsevier]

Abstract: Based on monadic datalog, we introduce the concept of weighted monadic datalog over unranked trees. This provides a query language that can be used to extract quantitative information from semi-structured databases where the quantities are taken from some semiring . We show that weighted monadic datalog is as expressive as weighted tree automata on unranked trees. Moreover, we prove that a query can be evaluated efficiently on an unranked tree provided that (i) is commutative and the underlying datalog program is non-circular or (ii) is a finite and commutative -cpo semiring. [Copyright &y& Elsevier]

Abstract: We show that the generalized variant of formal systems where the underlying equational specifications are membership equational theories, and where the rules are conditional and can have equations, memberships and rewrites in the conditions is reflective. We also show that membership equational logic, many-sorted equational logic, and Horn logic with equality are likewise reflective. These results provide logical foundations for reflective languages and tools based on these logics. [Copyright &y& Elsevier]

Abstract: Personal identification number (PIN) blocks are 64-bit strings that encode a PIN ready for encryption and secure transmission in banking networks. These networks employ tamper-proof hardware security modules (HSMs) to perform sensitive cryptographic operations, such as checking the correctness of a PIN typed by a customer. The use of these HSMs is controlled by an API designed to enforce security. PIN block attacks are unanticipated sequences of API commands which allow an attacker to determine the value of a PIN in an encrypted PIN block. This paper describes a framework for formal analysis of such attacks. Our analysis is probabilistic, and is automated using constraint logic programming and probabilistic model checking. [Copyright &y& Elsevier]

Abstract: We give a framework for developing the least model semantics, fixpoint semantics, and SLD-resolution calculi for logic programs in multimodal logics whose frame restrictions consist of the conditions of seriality (i.e. ) and some classical first-order Horn clauses. Our approach is direct and no special restriction on occurrences of and is required. We apply our framework for a large class of basic serial multimodal logics, which are parameterized by an arbitrary combination of generalized versions of axioms T, B, 4, 5 (in the form, e.g. ) and . Another part of the work is devoted to programming in multimodal logics intended for reasoning about multidegree belief, for use in distributed systems of belief, or for reasoning about epistemic states of agents in multiagent systems. For that we also use the framework, and although these latter logics belong to the mentioned class of basic serial multimodal logics, the special SLD-resolution calculi proposed for them are more efficient. [Copyright &y& Elsevier]

Abstract: Full first-order linear logic can be presented as an abstract logic programming language in Miller''s system Forum, which yields a sensible operational interpretation in the ‘proof search as computation’ paradigm. However, Forum still has to deal with syntactic details that would normally be ignored by a reasonable operational semantics. In this respect, Forum improves on Gentzen systems for linear logic by restricting the language and the form of inference rules. We further improve on Forum by restricting the class of formulae allowed, in a system we call G-Forum, which is still equivalent to full first-order linear logic. The only formulae allowed in G-Forum have the same shape as Forum sequents: the restriction does not diminish expressiveness and makes G-Forum amenable to proof theoretic analysis. G-Forum consists of two (big) inference rules, for which we show a cut elimination procedure. This does not need to appeal to finer detail in formulae and sequents than is provided by G-Forum, thus successfully testing the internal symmetries of our system. [Copyright &y& Elsevier]

Abstract: A conjunctive query problem is a problem to determine whether or not a tuple belongs to the answer of a conjunctive query over a database. In this paper, a tuple, a conjunctive query and a database in relational database theory are regarded as a ground atom, a nonrecursive function-free definite clause and a finite set of ground atoms, respectively, in inductive logic programming terminology. An acyclic conjunctive query problem is a conjunctive query problem with acyclicity. Concerned with the acyclic conjunctive query problem, in this paper, we present the hardness results of predicting acyclic conjunctive queries from an instance with a j-database of which predicate symbol is at most j-ary. Also we deal with two kinds of instances, a simple instance as a set of ground atoms and an extended instance as a set of pairs of a ground atom and a description. We mainly show that, from both a simple and an extended instances, acyclic conjunctive queries are not polynomial-time predictable with j-databases () under the cryptographic assumptions, and predicting acyclic conjunctive queries with 2-databases is as hard as predicting DNF formulas. Hence, the acyclic conjunctive queries become a natural example that the equivalence between subsumption-efficiency and efficient pac-learnability from both a simple and an extended instances collapses. [Copyright &y& Elsevier]

Abstract: We consider the problem of extending temporal deductive databases with stratified negation. We argue that the classical stratification test for deductive databases is too restrictive when one shifts attention to the temporal case. Moreover, as we demonstrate, the (more general) local stratification approach is impractical: detecting whether a temporal deductive database is locally stratified is shown to be co-NP hard (even if one restricts attention to programs that only use one predicate symbol and two constants). For these reasons we define temporal stratification, an intermediate notion between stratification and local stratification. We demonstrate that for the temporal deductive databases we consider, temporal stratification coincides with local stratification in certain important cases in which the latter is polynomial-time decidable. We then develop two algorithms for detecting temporal stratification. The first algorithm applies to linear-time temporal deductive databases and it is efficient and more general than existing approaches; however, the algorithm sacrifices completeness for efficiency since it does not cover the whole class of temporally stratified programs. The second algorithm applies to branching-time temporal deductive databases (which include as a special case the linear-time ones). This algorithm is more expensive from a computational point of view, but it covers the whole class of temporally stratified programs. We discuss the relative merits of the two algorithms and compare them with other existing approaches. [Copyright &y& Elsevier]

Abstract: Due to the usual incompleteness of information representation, any approach to assign a semantics to logic programs has to rely on a default assumption on the missing information. The stable model semantics, that has become the dominating approach to give semantics to logic programs, relies on the Closed World Assumption (CWA), which asserts that by default the truth of an atom is false. There is a second well-known assumption, called Open World Assumption (OWA), which asserts that the truth of the atoms is supposed to be unknown by default. However, the CWA, the OWA and the combination of them are extremal, though important, assumptions over a large variety of possible assumptions on the truth of the atoms, whenever the truth is taken from an arbitrary truth space. The topic of this paper is to allow any assignment (i.e. interpretation), over a truth space, to be a default assumption. Our main result is that our extension is conservative in the sense that under the “everywhere false” default assumption (CWA) the usual stable model semantics is captured. Due to the generality and the purely algebraic nature of our approach, it abstracts from the particular formalism of choice and the results may be applied in other contexts as well. [Copyright &y& Elsevier]

Abstract: First-order theories are ordered under logical entailment based on the amount of information derived from theories. In default logic, on the other hand, a theory contains default information as well as definite information. To order default theories, distinguishing different sorts of information is necessary to assess the information content of a default theory. For this purpose, we first introduce a multi-valued interpretation of default theories using a ten-valued bilattice. It distinguishes between definite and credulous/skeptical default information derived from a theory, and is used for ordering default theories based on their information contents. We then apply the technique to order nonmonotonic logic programs under the answer set semantics. The results of this paper provide a method for comparing default theories or nonmonotonic logic programs in a manner different from the conventional extension/model-based viewpoint. Moreover, they have important application to induction from nonmonotonic theories. [Copyright &y& Elsevier]

Abstract: Global SLS-resolution is a well-known procedural semantics for top–down computation of queries under the well-founded model. It inherits from SLDNF-resolution the linearity property of derivations, which makes it easy and efficient to implement using a simple stack-based memory structure. However, like SLDNF-resolution it suffers from the problem of infinite loops and redundant computations. To resolve this problem, in this paper we develop a new procedural semantics, called SLTNF-resolution, by enhancing Global SLS-resolution with loop cutting and tabling mechanisms. SLTNF-resolution is sound and complete w.r.t. the well-founded semantics for logic programs with the bounded-term-size property, and is superior to existing linear tabling procedural semantics such as SLT-resolution. [Copyright &y& Elsevier]

The logic of bunched implications, BI, is a substructural system which freely combines an additive (intuitionistic) and a multiplicative (linear) implication via bunches (contexts with two combining operations, one which admits Weakening and Contraction and one which does not). BI may be seen to arise from two main perspectives. On the one hand, from proof-theoretic or categorical concerns and, on the other, from a possible-worlds semantics based on preordered (commutative) monoids. This semantics may be motivated from a basic model of the notion of resource. We explain BI''s proof-theoretic, categorical and semantic origins. We discuss in detail the question of completeness, explaining the essential distinction between BI with and without ⊥ (the unit of ∨). We give an extensive discussion of BI as a semantically based logic of resources, giving concrete models based on Petri nets, ambients, computer memory, logic programming, and money. [Copyright &y& Elsevier]

This work introduces a transformation methodology for functional logic programs based on needed narrowing, the optimal and complete operational principle for modern declarative languages which integrate the best features of functional and logic programming. We provide correctness results for the transformation system w.r.t. the set of computed values and answer substitutions and show that the prominent properties of needed narrowing—namely, the optimality w.r.t. the length of derivations and the number of computed solutions—carry over to the transformation process and the transformed programs. We illustrate the power of the system by taking on in our setting two well-known transformation strategies (composition and tupling). We also provide an implementation of the transformation system which, by means of some experimental results, highlights the potentiality of our approach. [Copyright &y& Elsevier]

The different semantics that can be assigned to a logic program correspond to different assumptions made concerning the atoms that are rule heads and whose logical values cannot be inferred from the rules. For example, the well founded semantics corresponds to the assumption that every such atom is false, while the Kripke–Kleene semantics corresponds to the assumption that every such atom is unknown. In this paper, we propose to unify and extend this assumption-based approach by introducing parameterized semantics for logic programs. The parameter holds the value that one assumes for all rule heads whose logical values cannot be inferred from the rules. We work within multi-valued logic with bilattice structure, and we consider the class of logic programs defined by Fitting.Following Fitting''s approach, we define an operator that allows us to compute the parameterized semantic, and to compare and combine semantics obtained for different values of the parameter. We show that our approach captures and extends the usual semantics of conventional logic programs thereby unifying their computation. [Copyright &y& Elsevier]

The introduction of negation into logic programming brings the benefit of enhanced syntax and expressibility, but creates some semantical problems. Specifically, certain operators which are monotonic in the absence of negation become non-monotonic when it is introduced, with the result that standard approaches to denotational semantics then become inapplicable. In this paper, we show how generalized metric spaces can be used to obtain fixed-point semantics for several classes of programs relative to the supported model semantics, and investigate relationships between the underlying spaces we employ. Our methods allow the analysis of classes of programs which include the acyclic, locally hierarchical, and acceptable programs, amongst others, and draw on fixed-point theorems which apply to generalized ultrametric spaces and to partial metric spaces. [Copyright &y& Elsevier]

We propose a new framework for the syntax and semantics of Weak Hereditarily Harrop logic programming with constraints, based on resolution over τ-categories: finite product categories with canonical structure.Constraint information is directly built-in to the notion of signature via categorical syntax. Many-sorted equational are a special case of the formalism which combines features of uniform logic programming languages (moduels and hypothetical implication) with those of constraint logic programming. Using the cannoical structure supplied by τ-categories, we define a diagrammatic generalization of formulas, goals, programs and resolution proofs up to equality (rather than just up to isomorphism).We extend the Kowalski-van Emden fixed point interpretation, a cornerstone of declarative semantics, to an operational, non-ground, categorical semantics based on indexing over sorts and programs.We also introduce a topos-theoretic declarative semantics and show soundness and completeness of resolution proofs and of a sequent calculus over the categorical signature. We conclude with a discussion of semantic perspectives on uniform logic programming. [Copyright &y& Elsevier]

The elementary formal system (EFS) is a kind of logic programs which directly manipulates strings, and the learnability of the subclass called hereditary EFSs (HEFSs) has been investigated in the frameworks of the PAC-learning, query-learning, and inductive inference models. The hierarchy of HEFS is expressed by HEFS(m,k,t,r), where m, k, t and r denote the number of clauses, the occurrences of variables in the head, the number of atoms in the body, and the arity of predicate symbols. The present paper deals with the learnability of HEFS in the query learning model using equivalence queries and additional queries such as membership, predicate membership, entailment membership, and dependency queries. We show that the class HEFS(*,k,t,r) is polynomial-time learnable with the equivalence and predicate membership queries and the class HEFS(*,k,*,r) with termination property is polynomial-time learnable with the equivalence, entailment membership, and dependency queries for the unbounded parameter *. A lowerbound on the number of queries is presented. We also show that the class HEFS(*,k,t,r) is hard to learn with the equivalence and membership queries under the cryptographic assumptions. Furthermore, the learnability of the class of unions of regular pattern languages, which is a subclass of HEFSs, is investigated. The bounded unions of regular pattern languages are polynomial-time predictable with membership query. However, all unbounded unions of regular pattern languages are not polynomial-time predictable with membership queries if neither are the DNF formulas. [Copyright &y& Elsevier]

An elementary formal system (EFS) is a logic program such as a Prolog program, for instance, that directly manipulates strings. Arikawa and his co-workers proposed elementary formal systems as a unifying framework for formal language learning.In the present paper, we introduce advanced elementary formal systems (AEFSs), i.e., elementary formal systems which allow for the use of a certain kind of negation, which is nonmonotonic, in essence, and which is conceptually close to negation as failure.We study the expressiveness of this approach by comparing certain AEFS definable language classes to the levels in the Chomsky hierarchy and to the language classes that are definable by EFSs that meet the same syntactical constraints.Moreover, we investigate the learnability of the corresponding AEFS definable language classes in two major learning paradigms, namely in Gold''s model of learning in the limit and Valiant''s model of probably approximately correct learning. In particular, we show which learnability results achieved for EFSs extend to AEFSs and which do not. [Copyright &y& Elsevier]

For given logical formulae B and E such that B⊨E, hypothesis finding means the generation of a formula H such that B∧H⊨E. Hypothesis finding constitutes a basic technique for fields of inference, like inductive inference and knowledge discovery. In order to put various hypothesis finding methods proposed previously on one general ground, we use upward refinement and residue hypotheses. We show that their combination is a complete method for solving any hypothesis finding problem in clausal logic. We extend the relative subsumption relation, and show that some hypothesis finding methods previously presented can be regarded as finding hypotheses which subsume examples relative to a given background theory. Noting that the weakening rule may make hypothesis finding difficult to solve, we propose restricting this rule either to the inverse of resolution or to that of subsumption. We also note that this work is related to relevant logic. [Copyright &y& Elsevier]

We present a goal-independent abstract interpretation framework for constraint logic programs, and prove the sufficiency of a set of conditions for abstract domains to ensure that the analysis will never lose precision. Along the way, we formally define constraint logic programming systems, give a formal semantics that is independent of the actual constraint domain and the details of the proof algorithm, and formally define the maximally precise abstraction of a constraint logic program. [Copyright &y& Elsevier]

This paper relates the Defeasible Logic Programming (DeLP) framework and its semantics SEMDeLP to classical logic programming frameworks. In DeLP, we distinguish between two different sorts of rules: strict and defeasible rules. Negative literals (∼A) in these rules are considered to represent classical negation. In contrast to this, in normal logic programming (NLP), there is only one kind of rules, but the meaning of negative literals (not A) is different: they represent a kind of negation as failure, and thereby introduce defeasibility. Various semantics have been defined for NLP, notably the well-founded semantics (WFS) (van Gelder et al., Proceedings of the Seventh Symposium on Principles of Database Systems, 1988, pp. 221–230; J. ACM 38 (3) (1991) 620) and the stable semantics Stable (Gelfond and Lifschitz, Fifth Conference on Logic Programming, MIT Press, Cambridge, MA, 1988, pp. 1070–1080; Proceedings of the Seventh International Conference on Logical Programming, Jerusalem, MIT Press, Cambridge, MA, 1991, pp. 579–597).In this paper we consider the transformation properties for NLP introduced by Brass and Dix (J. Logic Programming 38(3) (1999) 167) and suitably adjusted for the DeLP framework. We show which transformation properties are satisfied, thereby identifying aspects in which NLP and DeLP differ. We contend that the transformation rules presented in this paper can help to gain a better understanding of the relationship of DeLP semantics with respect to more traditional logic programming approaches. As a byproduct, we obtain the result that DeLP is a proper extension of NLP. [Copyright &y& Elsevier]

Liberatore and Schaerf (Proceedings of the ECAI’ 98, 1998) give a proof that model checking for propositional normal default theories is in Δ2P and Δ2P[O(log n)]-hard. However, the precise complexity is left as an open problem. We solve this problem by proving that model checking for normal default theories is complete for Δ2P[O(log n)]. This is the class of decision problems solvable in polynomial time with a logarithmic number of calls to an oracle in NP. Additionally, we analyse the computational cost of model checking w.r.t. weak extensions, stable expansions and N-expansions and take a look at the complexity of model checking for disjunction-free default theories. Furthermore, we show that not only for disjunction-free default theories, but also for a larger class of default theories, which we call default theories in extended Horn normal form, the complexity of model checking is, in the case of normal default theories, tractable. Additionally, the complexity results are used to draw some interesting conclusions on translatability issues. In particular, there exists no function from default logic into logic programming which is polynomial, faithful and modular unless coNP = Σ2P. Finally, we give an overview of our results concerning model checking in case of disjunctive default logic and stationary default logic. [Copyright &y& Elsevier]

We present a static analysis that detects potential runtime exceptions that are raised and never handled inside Standard ML (SML) programs. This analysis will predict abrupt termination of SML programs, which is SMLs only one “safety hole”. Even though SML program''s control flow and exception flow are in general mutually dependent, analyzing the two flows are safely decoupled. Program''s control flow is firstly estimated by simple case analysis of call expressions. Using this call-graph information, program''s exception flow is derived as set constraints, whose least model is our analysis result. Both of these two analyses are proven safe and the reasons behind each design decision are discussed.Our implementation of this analysis has been applied to realistic SML programs and shows a promising cost-accuracy performance. For the ML-Lex program, for example, the analysis takes 1.36 s and it reports 3 may-uncaught exceptions, which are exactly the exceptions that can really escape. Our final goal is to make the analysis overhead less than 10% of the compilation time (compiling the ML-Lex takes 6–7 s) and to analyze modules in isolation. [Copyright &y& Elsevier]

In the context of the abstract interpretation theory, we study the relations among various abstract domains for groundness analysis of logic programs. We reconstruct the well-known domain Pos as a logical domain in a fully automatic way and we prove that it is the best abstract domain which can be set up from the property of groundness by applying logic operators only. We propose a new notion of optimality which precisely captures the relation between Pos and its natural concrete domain. This notion enables us to discriminate between the various abstract domains for groundness analysis from a computational point of view and to compare their relative precision. Finally, we propose a new domain for groundness analysis which has the advantage of being independent from the specific program and we show its optimality. [Copyright &y& Elsevier]

Although the usual goal of sharing analysis is to detect which pairs of variables share, the standard choice for sharing analysis is a domain that characterizes set-sharing. In this paper, we question, apparently for the first time, whether this domain is over-complex for pair-sharing analysis. We show that the answer is yes. By defining an equivalence relation over the set-sharing domain we obtain a simpler domain, reducing the complexity of the abstract unification procedure. We present experimental results showing that, in practice, our domain compares favorably with the set-sharing one over a wide range of benchmark and real programs. [Copyright &y& Elsevier]

In (Gerla and Sessa, Fuzzy Logic and Soft Computing, Kluwer, Norwell, 1999, pp. 19–31) a methodology that allows to manage uncertain and imprecise information in the frame of the declarative paradigm of Logic Programming has been proposed. With this aim, a Similarity relation R between function and predicate symbols in the language of a logic program is considered. Approximate inferences are then possible since similarity relation allows us to manage alternative instances of entities that can be considered “equal” with a given degree. The declarative semantics of the proposed transformation technique of logic programs is analyzed. The notion of fuzzy least Herbrand model is also introduced. In this paper the corresponding operational semantics is provided by introducing a modified version of SLD resolution. This top-down refutation procedure overcomes failure situations in the unification process by using the similarity relation. A generalized notion of most general unifier provides a numeric value which gives a measure of the exploited approximation. In this way, the SLD resolution is enhanced since it is possible both to handle uncertain or imprecise information, and to compute approximate answer substitutions, with an associated approximation-degree, when failures of the exact inference process occur. It can lead to the implementation of a more general PROLOG interpreter, without detracting from the elegance of the language. [Copyright &y& Elsevier]