An order-sorted query system for sort, predicate, and meta-predicate hierarchies

This paper presents a decidable order-sorted query system for reasoning between ontologies and rules. We describe order-sorted logic programming with sort, predicate, and meta-predicate hierarchies (OSL_3h), which derives predicate and meta-predicate assertions. Meta-level predicates (predicates of predicates) are useful for representing relationships between predicate formulas, and further, they conceptually yield a hierarchy similar to the hierarchies of sorts and predicates. By extending the order-sorted Horn-clause calculus, we develop a query-answering system in OSL_3h that can answer queries such as atoms and meta-atoms generalized by containing predicate variables. We show that the expressive query-answering system computes every generalized query in single exponential time, that is, the complexity of our query system is equal to that of DATALOG.     

An intelligent modeling and analysis method of manufacturing process using the first-order predicate logic

Manufacturing process refers to machining sequence from raw materials to final products. Process plan has important effects on manufacturing process. In general, process designer relies on his experience and knowledge to arrange the process plan. For a complex part, it takes long time and effort to determine process plan. In this paper, an intelligent modeling and analysis method using the first-order predicate logic is proposed to evaluate the manufacturing performance. First, the logic predicates used to represent the process plan are defined according to the machining methods, and the predicate variables are discussed in detail. Consequently, the process plan can be represented in the form of the first-order predicate logic. Second, a type of element model composed of four nodes and four links is put forward in order to construct the process model. All components in this element model are respectively explained, and the mapping relationship between element model and predicate logic is described in detail. According to engineering practices, logic inference rules are suggested and the inference process is illustrated. Hence, the manufacturing process model can be constructed. Third, the process simulation is carried out to evaluate the performance of manufacturing system by using measures such as efficiency, the machine utilization, etc. Finally, a case study is given to explain this intelligent modeling method using the first-order predicate logic.     

一阶模糊谓词逻辑公式的有限解释真度和可数解释真度的理论及其应用

通过引进公式变元集赋值的新概念给出了一阶模糊谓词逻辑（或一阶模糊语言）公式的有限解释真度及可数解释真度的定义,并讨论了它们的一系列性质及其在近似推理中的应用,从而为一阶谓词逻辑的近似推理理论提供了一种带度量的框架.     

Programming in temporal-nonmonotonic reasoning

Nonmonotonic reasoning has been proposed as an extension to classical first-order logic. Now people are interested in temporal reasoning with nonmonotonic logic [6]. We combine the monotonic logic [7] with a temporal logic to get a more general reasoning language. We discuss a monotonic logic TML which has predicate formulas, temporal formulas and a special modal formula, and give a completeness theorem of it. We use TH() to designate the set of theorems of a temporal-nonmonotonic theory which has the same language with TML. The completeness theorem of the temporal-nonmonotonic logic naturally arises. Like the relationship between predicate logic with a practical logic programming language PROLOG, we propose a useful temporal-nonmonotonic reasoning language TN for the temporal-nonmonotonic logic. As an appendix we supply an algorithm for the programming language TN.     

Linking temporal first-order logic with Bayesian networks for the simulation of pervasive computing systems

The authors’ previous work discussed a scalable abstract knowledge representation and reasoning scheme for Pervasive Computing Systems, where both low-level and abstract knowledge is maintained in the form of temporal first-order logic (TFOL) predicates. Furthermore, we introduced a novel concept of a generalised event, an abstract event, which we define as a change in the truth value of an abstract TFOL predicate. Abstract events represent real-time knowledge about the system and they are defined with the help of well-formed TFOL expressions whose leaf nodes are concrete, low-level events using our AESL language.In this paper, we propose to simulate pervasive systems by providing estimated knowledge about its entities and situations that involve them. To achieve this goal, we enhance AESL with higher-order function predicates that denote approximate knowledge about the likelihood of a predicate instance having the value True with respect to a time reference. We define a mapping function between a TFOL predicate and a Bayesian network that calculates likelihood estimates for that predicate as well as a confidence level, i.e., a metric of how reliable the likelihood estimation is for that predicate.Higher-order likelihood predicates are implemented by a novel middleware component, the Likelihood Estimation Service (LES). LES implements the above mapping; first, for each abstract predicate, it learns a Bayesian network that corresponds to that predicate from the knowledge stored in the sensor-driven system. Once trained and validated, the Bayesian networks generate a likelihood estimate and a confidence level. This new knowledge is maintained in the middleware as approximate knowledge therefore providing a simulation of the pervasive system, in the absence of real-time data. Last but not least, we describe an experimental evaluation of our system using the Active BAT location system.     

Existential rigidity and many modalities in order-sorted logic

Order-sorted logic is a useful tool for knowledge representation and reasoning because it enables representation of sorted terms and formulas along with partially ordered sorts (called sort-hierarchy). However, this logic cannot represent more complex sorted expressions when they are true in any possible world (as rigid) or some possible worlds (as modality) such as time, space, belief, or situation. In this study, we extend order-sorted logic by introducing existential rigidity and many modalities. In the extended logic, sorted modal formulas are interpreted over the Cartesian product of sets of possible worlds. We present a new labeled tableau calculus to check the (un)satisfiability and validity of sorted modal formulas.     

EVENT INFERENCE WITH RELATION AND META-RELATION TYPE HIERARCHIES IN CONCEPTUAL STRUCTURE THEORY

□ This article proposes a method to perform automated inference from event assertions through the use of an ontology formalized under Conceptual Structure Theory. An upper event ontology is first presented as an example of how the ontology is built and how real-life event assertions and their relations are modeled into its hierarchies of type. Three different types are distinguished: an event type as a basic classification of events of similar nature, an event relation type as a predicate on event types, and an event meta-relation type as a “predicate of predicates” on event types, with formal relationships between them and their properties elicited. The proposed formalization could be leveraged by search engines on the Semantic Web and query-answering systems in specific domains of discourse.     

基于位串编码的遗传归纳逻辑程序设计

归纳逻辑程序设计是基于一阶逻辑的数据挖掘新方法。一阶规则挖掘是目标谓词和背景知识谓词对应的各种原子的复杂组合优化问题。该文根据Occam’s razor原理提出原子的位串编码,设计相应的遗传箅子,基于sequential covering策略提出采用遗传算法作为搜索策略的遗传归纳逻辑程序设计算法GILP。在连通图问题和gcd问题上验证算法的可行性。     

基于概率和条件逻辑的PKI信任模型推理

提出一种基于概率和条件谓词逻辑来表示和推导PKI信任模型的方法．该方法用3个二元条件谓词表示不同个体之间的关系,并给出了实体认证规则、信任规则和信任扩展规则，对信任度定义了一个概率模型，该模型能反映约束条件如何影响信任度．概率模型加条件谓词逻辑能够对一个PKI信任模型进行更精确的描述．     

Default reasoning and belief revision: A syntax-independent approach

As an important variant of Reiter‘s default logic.Poole(1988) developed a nonmonotonic reasoning framework in the classical first-order language,Brewka and Nebel extended Poole‘s approach in order to enable a representation of priorities between defaults.In this paper a general framework for default reasoning is presented,which can be viewed as a generalization of the three approaches above.It is proved that the syntax-independent default reasoning in this framework is identical to the general belief revision operation introduced by Zhang et al.(1997).This esult provides a solution to the problem whether there is a correspondence between belief revision and default logic for the infinite case .As a by-product,an answer to the the question,raised by Mankinson and Gaerdenfors(1991),is also given about whether there is a counterpart contraciton in nonmonotonic logic.     

基于格值一阶逻辑LF（X）的自动推理算法

基于谓词逻辑的归结推理方法是目前理论上较为成熟、可以在计算机上实现的推理方法之一。针对格值一阶逻辑LF(X)中归结自动推理问题,以格值一阶逻辑LF(X)的α-归结原理为理论基础,通过对例子进行分析,提出了LF(X)中简单广义子句集的归结自动推理算法,并证明了该算法的可靠性和完备性。     

Towards a logic programming methodology based on higher-order predicates

This paper outlines a logic programming methodology which applies standardized logic program recursion forms afforded by a system of general purpose recursion schemes. The recursion schemes are conceived of as quasi higher-order predicates which accept predicate arguments, thereby representing parameterized program modules. This use of higher-order predicates is analogous to higher-order functionals in functional programming. However, these quasi higher-order predicates are handled by a metalogic programming technique within ordinary logic programming. Some of the proposed recursion operators are actualizations of mathematical induction principles (e.g. structural induction as generalization of primitive recursion). Others are heuristic schemes for commonly occurring recursive program forms. The intention is to handle all recursions in logic programs through the given repertoire of higher-order predicates. We carry out a pragmatic feasibility study of the proposed recursion operators with respect to the corpus of common textbook logic programs. This pragmatic investigation is accompanied with an analysis of the theoretical expressivity. The main theoretical results concerning computability are

1. Primitive recursive functions can be re-expressed in logic programming by predicates defined solely by non-recursive clauses augmented with afold recursion predicate akin to the fold operators in functional programming.
2. General recursive functions can be re-expressed likewise sincefold allows re-expression of alinrec recursion predicate facilitating linear, unbounded recursion.

     

Simplifying dynamic programming via mode‐directed tabling

In the dynamic programming paradigm the value of an optimal solution is recursively defined in terms of optimal solutions to subproblems. Such dynamic programming definitions can be tricky and error‐prone to specify. This paper presents an elegant method based on tabled logic programming (TLP) that simplifies the specification of such dynamic programming solutions. Our method introduces a new mode declaration for tabled predicates. The arguments of each tabled predicate are divided into indexed and non‐indexed arguments so that tabled predicates can be regarded as functions: indexed arguments represent input values and non‐indexed arguments represent output values. The non‐indexed arguments in a tabled predicate can be further declared to be aggregated, for example, the minimum, so that while generating answers, the global table will dynamically maintain the smallest value for that argument. This mode‐declaration scheme, coupled with recursion, provides an easy‐to‐use method for dynamic programming: there is no need to define the value of an optimal solution recursively, as the definition of a general solution suffices. The optimal value as well as its corresponding concrete solution can be derived implicitly and automatically using tabled logic programming systems. Our experimental results show that mode declarations improve performance in solving dynamic programming problems on TLP systems. Copyright © 2007 John Wiley & Sons, Ltd.     

A Default Logic Based Framework for Context-Dependent Reasoning with Lexical Knowledge

Lexical knowledge is increasingly important in information systems—for example in indexing documents using keywords, or disambiguating words in a query to an information retrieval system, or a natural language interface. However, it is a difficult kind of knowledge to represent and reason with. Existing approaches to formalizing lexical knowledge have used languages with limited expressibility, such as those based on inheritance hierarchies, and in particular, they have not adequately addressed the context-dependent nature of lexical knowledge. Here we present a framework, based on default logic, called the dex framework, for capturing context-dependent reasoning with lexical knowledge. Default logic is a first-order logic offering a more expressive formalisation than inheritance hierarchies: (1) First-order formulae capturing lexical knowledge about words can be inferred; (2) Preferences over formulae can be based on specificity, reasoning about exceptions, or explicit priorities; (3) Information about contexts can be reasoned with as first-order formulae formulae; and (4) Information about contexts can be derived as default inferences. In the dex framework, a word for which lexical knowledge is sought is called a query word. The context for a query word is derived from further words, such as words in the same sentence as the query word. These further words are used with a form of decision tree called a context classification tree to identify which contexts hold for the query word. We show how we can use these contexts in default logic to identify lexical knowledge about the query word such as synonyms, antonyms, specializations, meronyms, and more sophisticated first-order semantic knowledge. We also show how we can use a standard machine learning algorithm to generate context classification trees.     

Inductive inference of regular languages based on model inference

This paper is concerned with an algorithm for identifying an unknown regular language from examples of its members and non-members. The algorithm is based on the model inference algorithm given by Shapiro. In our setting, however, a given first order language for describing a target logic program has countably many unary predicate symbols: q ₀,q ₁,q ₂…. On the other hand, the oracle which gives information about the unknown regular language to the inference algorithm has no interpretation for predicates other than the predicate q ₀. In such a setting,we cannot directly take advantage of the contradiction backtracing algorithm which is one of the most important parts for the efficiency of the model inference algorithm. In order to overcome this disadvantage, we develop a method for giving an interpretation for predicates other than the predicate q ₀ indirectly, which is based on the idea of using the oracle and a one to one mapping from a set of predicates to a set of strings. Furthermore, we propose a model inference algorithm for regular languages using the method, then argue the correctness and the time complexity of the algorithm     

Predicate abstractions in higher-order logic programming

Lambda calculus offers a natural representation of syntactic structures involving higher-order constructs and local variables, and supports flexible manipulation of such concepts. Thus an integration of logic programming with λ-terms would provide more direct support for metaprogramming. While it is conceptually straightforward to replace first-order terms with λ-terms, the extra search space in unification with respect to λ-conversions cannot be ignored from a practical point of view. Our objective is to explore useful alternatives with weaker conversions that are computationally more tractable. In this paper, we study predicate abstractions, in which λ-abstractions are used to provide anonymous predicates and functions that return predicates. The frameworks is based upon a simple logic of (untyped) λ-calculus, calledL _a .L _a has a general model-theoretic semantics and an equality theory that corresponds to α-equivalence. Intended meanings of predicate abstractions are formalized by equivalence axioms over atomic formulas. We show that under certain conditions, computing with predicate abstractions does not incur any extra search space. Furthermore, programs in this language can be compiled statically into efficient Prolog programs and all most general answers are still preserved.     

Programmed Strategies for Program Verification

Plover is an automated property-verifier for Haskell programs that has been under development for the past three years as a component of the Programatica project. In Programatica, predicate definitions and property assertions written in P-logic, a programming logic for Haskell, can be embedded in the text of a Haskell program module. Properties refine the type system of Haskell but cannot be verified by type-checking alone; a more powerful logical verifier is needed.Plover codes the proof rules of P-logic, and additionally, embeds strategies and decision procedures for their application and discharge. It integrates a reduction system that implements a rewriting semantics for Haskell terms with a congruence-closure algorithm that supports reasoning with equality. It employs strategies such as structure splitting and case analysis to explore alternative valuations of expressions of type Bool or other finite data types, but these strategies can lead to exponential growth of terms and must be employed cautiously.Plover itself is written in Stratego, which has proven to be a powerful language tool for implementating a verifier. We discuss the design and implementation of some strategies that enable Plover to comprehend Haskell and verify many valid property assertions.     

A LOGIC PROGRAMMING APPROACH TO HYBRID KNOWLEDGE REPRESENTATION

A new hybrid system called Sphinx is presented which combines classification-based reasoning with logic programming technique. It consists of two major components: a terminological component and an assertional one. The former uses a frame-based knowledge representation scheme based on classification and the latter is a theorem prover based on Horn logic. The assertional component can also handle a first-order query language and wh-questions. A new knowledge base maintenance mechanism based on the negation as failure inference rule enables Sphinx to support incremental assertions and retractions. In addition, Sphinx provides explanation capability to help the user in developing and debugging knowledge bases.