Many-sorted Logic Research Articles

Refactoring the Whitby Intelligent Tutoring System for Clean Architecture

AbstractWhitby is the server-side of an Intelligent Tutoring System application for learning System-Theoretic Process Analysis (STPA), a methodology used to ensure the safety of anything that can be represented with a systems model. The underlying logic driving the reasoning behind Whitby is Situation Calculus, which is a many-sorted logic with situation, action, and object sorts. The Situation Calculus is applied to Ontology Authoring and Contingent Scaffolding: the primary activities within Whitby. Thus many fluents and actions are aggregated in Whitby from these two sub-applications and from Whitby itself, but all are available through a common situation query interface that does not depend upon any of the fluents or actions. Each STPA project in Whitby is a single situation term, which is queried for fluents that include the ontology, and to determine what pedagogical interventions to offer. Initially Whitby was written in Prolog using a module system. In the interest of a cleaner architecture and implementation with improved code reuse and extensibility, the initial application was refactored into Logtalk. This refactoring includes decoupling the Situation Calculus reasoner, Ontology Authoring framework, and Contingent Scaffolding framework into third-party libraries that can be reused in other applications. This extraction was achieved by inverting dependencies via Logtalk protocols and categories, which are reusable interfaces and components that provide functionally cohesive sets of predicate declarations and predicate definitions. In this paper the architectures of two iterations of Whitby are evaluated with respect to the motivations behind the refactor: clean architecture enabling code reuse and extensibility.

Many-sorted hybrid modal languages

We continue our investigation into using the hybridization technique on top of the many-sorted polyadic modal logic we have previously defined. By adding different operators and binders, we present in this paper several systems we have developed. We briefly discuss the goals we have achieved by developing each system. We identify a fragment of the full hybrid logic, for which we prove its sound and complete deduction and we show that it is powerful enough to represent both the programs and their semantics in an uniform manner. Finally, we provide a standard translation from full hybrid many-sorted logic to first-order logic.

Inductive verification of data model invariants in web applications using first-order logic

Modern software applications store their data in remote cloud servers. Users interact with these applications using web browsers or thin clients running on mobile devices. A key concern for these applications is the correctness of the actions that update the data store, which are triggered by user requests. Considering that modern applications store and manage data for millions (even billions) of users, misuse or loss of user data can have catastrophic consequences. In this paper, we focus on automated discovery of data store bugs in applications that use development frameworks that are RESTful, enforce the Model–View–Controller architecture, and use Object Relational Mapping libraries to manipulate data. We present a formal data model for data stores and data store manipulation in such applications. We have developed a framework for verification of data models via translation to First Order Logic (FOL), followed by automated theorem proving. Due to the undecidability of FOL, this automated approach does not always produce a conclusive answer. We investigate the use of many-sorted logic in data model verification in order to improve the effectiveness of this approach. Many-sorted logic allows us to specify type information explicitly, thus lightening the burden of reasoning about type information during theorem proving. Our experimental results demonstrate that our verification approach is scalable to real-world web applications and is able to detect bugs in them.

A many-sorted theory proposal for information retrieval: axiomatization and semantics

Logic-based models have been already proposed for information retrieval purpose. However, there is a need for new formalisms providing more generic frameworks. For this purpose, an information retrieval axiomatic theory is proposed in this paper, independently of any model. Our proposal which mainly relies on many-sorted logic allows to consider various sets in the domain of discourse that provides us a rich framework to model the different items such as documents, index terms, queries. The theory relies on a sound set of axioms driving the retrieval process as proof of theorems. As such the genericity consists of a main motivation; it will be proved that three classical information retrieval models, namely the Boolean model; the fuzzy-set-based extension of the Boolean model; and the vector space model, satisfy the proposed theory, establishing then its consistency. Beyond the genericity, the proposed approach may face concrete problems. Indeed, it is well known that the use of the classical settings of formal concept analysis theory for information retrieval does not allow disjunctions and negations in queries. For this purpose, this paper gives a characterization of these queries forms using appropriates theorems of the theory. Useful algebraic properties (i.e., isomorphisms) are then established for this end.

Quine’s conjecture on many-sorted logic

Quine often argued for a simple, untyped system of logic rather than the typed systems that were championed by Russell and Carnap, among others. He claimed that nothing important would be lost by eliminating sorts, and the result would be additional simplicity and elegance. In support of this claim, Quine conjectured that every many-sorted theory is equivalent to a single-sorted theory. We make this conjecture precise, and prove that it's true, at least according to one reasonable notion of theoretical equivalence. Our clarification of Quine's conjecture, however, exposes the shortcomings of his argument against many-sorted logic.

First-order logic system $\mathbf{IMTL_{Q}^{*}}$ and triple I method in fuzzy reasoning with linguistic quantifiers

Based on first-order fuzzy logic system $\mathbf{K}^{*}$ and Ying's framework for linguistic quantifiers modeled by Sugeno integrals, a many-sorted first-order logic system $\mathbf{IMTL_{Q}^{*}}$ is constructed. Applying the triple I method, some fuzzy reasoning forms with linguistic quantifiers are investigated.

An approach to the formal analysis of license interoperability

With recent advances in information and telecommunications technologies, a large range of digital content is distributed over the Internet. Whereas diverse licenses are provided to protect the content legally and have the advantage of offering authors many choices, the obstruction of smooth content distribution may occur if the relationships between licenses are not revealed because of differences between the restrictions imposed by each license. To activate digital content distribution, license interoperability must be revealed. In this paper, we propose a framework for formally examining license interoperability by using many-sorted first-order logic. We formalize five actual licenses and examine their interoperability to prove the effectiveness of our proposed framework. The results show that the framework reveals the relationships between licenses.

A logical formulation of the granular data model

In data mining problems, data is usually provided in the form of data tables. To represent knowledge discovered from data tables, decision logic (DL) is proposed in rough set theory. While DL is an instance of propositional logic, we can also describe data tables by other logical formalisms. In this paper, we use a kind of many-sorted logic, called attribute value-sorted logic, to study association rule mining from the perspective of granular computing. By using a logical formulation, it is easy to show that patterns are properties of classes of isomorphic data tables. We also show that a granular data model can act as a canonical model of a class of isomorphic data tables. Consequently, association rule mining can be restricted to such granular data models.

Decidable fragments of many-sorted logic

Many natural specifications use types. We investigate the decidability of fragments of many-sorted first-order logic. We identified some decidable fragments and illustrated their usefulness by formalizing specifications considered in the literature. Often the intended interpretations of specifications are finite. We prove that the formulas in these fragments are valid iff they are valid over the finite structures. We extend these results to logics that allow a restricted form of transitive closure. We tried to extend the classical classification of the quantifier prefixes into decidable/undecidable classes to the many-sorted logic. However, our results indicate that a naive extension fails and more subtle classification is needed.

Automatic extraction of knowledge from student essays

This paper presents a characterisation of argumentation in student essays and analyses patterns for extracting knowledge from them. Having analysed their complexity in light of the kinds of logic that may be used in an automatic argumentation extraction system, the main characteristic of these patterns appears to be the polymorphism of the pattern variables. Therefore, systems that learn patterns automatically ought to be able to generate many-sorted logic formulae, so that polymorphic types may be associated to the extraction slots (or - equivalently - to a logic formulae). An analysis of existing (pattern learning) systems was carried out to gauge the possibility of using them within our framework. However, we concluded that none of the existing systems can handle our requirements. Finally, we present our vision of an agent-based student portal as the front-end of a system that can locate argumentation links in a student essay and integrates with related educational services.

A general framework for reasoning about change

The capability to represent and use concepts like time and events in computer science is essential to solve a wide class of problems characterized by the notion of change. Real-time, databases and multimedia are just a few of several areas which needs good tools to deal with time. Another area where this concepts are essential is artificial intelligence because an agent must be able to reason about a dynamic environment.In this work a formalism is proposed which allows the representation and use of several features that had been recognized as useful in the attempts to solve such class of problems. A general framework based on a many-sorted logic is proposed centering our attention in issues such as the representation of time, actions, properties, events and causality. The proposal is compared with related work from the temporal logic and artificial intelligence areas. This work complements and enhances previously related efforts on formalizing temporal concepts with the same purpose.

Nominal logic, a first order theory of names and binding

This paper formalises within first-order logic some common practices in computer science to do with representing and reasoning about syntactical structures involving lexically scoped binding constructs. It introduces Nominal Logic , a version of first-order many-sorted logic with equality containing primitives for renaming via name-swapping, for freshness of names, and for name-binding. Its axioms express properties of these constructs satisfied by the FM-sets model of syntax involving binding, which was recently introduced by the author and M.J. Gabbay and makes use of the Fraenkel–Mostowski permutation model of set theory. Nominal Logic serves as a vehicle for making two general points. First, name-swapping has much nicer logical properties than more general, non-bijective forms of renaming while at the same time providing a sufficient foundation for a theory of structural induction/recursion for syntax modulo α -equivalence. Secondly, it is useful for the practice of operational semantics to make explicit the equivariance property of assertions about syntax – namely that their validity is invariant under name-swapping.

Temporal Defeasible Reasoning

An argumentation system that allows temporal reasoning using the notions of instant and interval is presented. Previous proposals just considered either instants or intervals. A many-sorted logic is used to represent temporal knowledge at the monotonic level. The logic considers how to formalize knowledge about explicit temporal references, events, properties and actions. The argumentation system provides a non-monotonic layer in which to reason about the justification of truths in the system. The proposal is illustrated showing how to solve well-known problems of the literature.

ADL: An Activity Description Language for Real-Time Networks

Abstract. This paper introduces and motivates ADL, a new formal notation for the specification of the temporal and functional behaviour of concurrent processes. ADL is tailored to be directly compatible with the DORIS design method. It combines a graphical Activity State-Machine (ASM) notation and a model-based Activity Functional Behaviour (AFB) notation. The abstract syntax, and static and dynamic semantics for the ASM notation are given, the dynamic semantics being given proof-theoretically in many-sorted logic extended with the RTL ‘occurrence’ relation, Θ , and the ERTL ‘holding’ relation, Φ . ADL is used to specify a small network, and proofs are given of its timeliness and safety properties.

Swinging types=functions+relations+transition systems

Swinging types provide an integrated framework for specifying software on the basis of many-sorted logic in terms of “static” functions and relations as well as “dynamic” transition systems. Swinging types combine equational, Horn and modal logic for the purpose of using evaluation and proof rules from all three logics for rapid prototyping and verification. A swinging specification separates from each other visible sorts that denote domains of data identified by their structure; hidden sorts that denote domains of data identified by their behavior in response to observers; μ- predicates, i.e., least relations representing inductive(ly provable) properties of a system; and ν- predicates, i.e., greatest relations representing complementary “coinductive” properties, which often describe behavioral aspects “in the infinity”. Programming paradigms, such as functional, relational or state-oriented ones, and specification formalisms, such as algebraic, set-theoretic, rule-based, net-based, coalgebraic, order-theoretic ones, usually handle either static or dynamic components, either structural or behavioral aspects of a system. Swinging types admit the integrated design and analysis of these components and aspects. An integrated model is obtained naturally if all entities (objects, states, etc.) of the system are presented as terms built up of constructors for visible or hidden sorts, functions are specified in terms of conditional equations (=functional programs), least relations in terms of Horn clauses (=logic programs or transition system specifications) and greatest relations in terms of co-Horn clauses. Data equalities are either structural or behavioral, the former being least, the latter being greatest solutions of axioms that are determined by (components of) the type's signature. This paper mainly presents the theoretical foundations of swinging types, such as standard (term) models, criteria for structural and behavioral consistency, and proof rules. Swinging types admit flexible design guidelines, tailored to particular objectives or application fields. Suitable design methods may be based upon this and the companion paper [61] that explores various application areas and illustrates how swinging types may realize different programming or specification styles. As to structuring concepts for swinging types, parameterization and genericity are involved in this paper, while [64] deals with extensions and refinements.

Using Many-Sorted Logic in the Object-Oriented Data Model for Fast Robot Task Planning

Search space explosion is a critical problem in robot task planning. This problem limits current robot task planners to solve only simple block world problems and task planning in a real robot working environment to be impractical. This problem is mainly due to the lack of utilization of domain information in task planning. In this paper, we describe a fast task planner for indoor robot applications that effectively uses domain information to speed up the planning process. In this planner, domain information is explicitly represented in an object-oriented data model (OODM) that uses many-sorted logic (MSL) representation. The OODM is convenient for the management of complex data and many-sorted logic is effective for pruning in the rule search process. An inference engine is designed to take advantage of the salient features of these two techniques for fast task planning. A simulation example and complexity analysis are given to demonstrate the advantage of the proposed task planner.

Handling inheritance in a system integrating logic in objects

The inheritance mechanism of SILO, a system integrating a many-sorted logic within an object-based framework, is presented. In order to be adequate for knowledge representation, it comprises two components, a hardwired and a user-definable. Due to use of typed (sorted) terms, a variety of specialisation types between logical formulas (axioms) are introduced and defined. Thus, the hardwired component is able to represent a variety of inheritance/specialisation relations between objects. The notion of a conflict is defined and conflict detection theorems are introduced. Also, consequence retraction is introduced and used alongside attribute/predicate overriding to resolve conflicts. The user-definable component consists of a number of user definable functions, called meta-functions, which are able to implement both global and local inheritance control. It is based on a partial reflection meta-level architecture.

SILO: INTEGRATING LOGIC IN OBJECTS FOR KNOWLEDGE REPRESENTATION AND REASONING

There have been a large number of systems that integrate logic and objects (frames or classes) for knowledge representation and reasoning. Most of those systems give pre-eminence to logic and their objects lack the structure of frames. These choices imply a number of disadvantages, as the inability to represent exceptions and perform default reasoning, and the reduction in the naturalness of representation. In this paper, aspects of knowledge representation and reasoning in SILO, a system integrating logic in objects, are presented. SILO gives pre-eminence to objects. A SILO object comprises elements from both frames and classes. A kind of many-sorted logic is used to express object internal knowledge. Message passing, alongside inheritance, plays a significant role in the reasoning process. Control knowledge, concerning both deduction and inheritance. is separately and explicitly represented via definitions of certain functions, called meta-functions.

Type reducing correspondences and well-orderings: Frege's and Zermelo's constructions re-examined

A key idea in both Frege's development of arithmetic in the Grundlagen [7] and Zermelo's 1904 proof [10] of the well-ordering theorem is that of a “type reducing” correspondence between second-level and first-level entities. In Frege's construction, the correspondence obtains between concept and number, in Zermelo's (through the axiom of choice), between set and member. In this paper, a formulation is given and a detailed investigation undertaken of a system ℱ of many-sorted first-order logic (first outlined in the Appendix to [6]) in which this notion of type reducing correspondence is accorded a central role and which enables Frege's and Zermelo's constructions to be presented in such a way as to reveal their essential similarity. By adapting Bourbaki's version of Zermelo's proof of the well-ordering theorem, we show that, within ℱ, any correspondence c between second-level entities (here called concepts) and first-level ones (here called objects) induces a well-ordering relation W (c) in a canonical manner. We shall see that, when c is the “Fregean” correspondence between concepts and cardinal numbers, W (c) is (the well-ordering of) the ordinal ω + 1, and when c is a “Zermelian” choice function on concepts, W (c) is a well-ordering of the universal concept embracing all objects.In ℱ an important role is played by the notion of extension of a concept. To each concept X we assume there is assigned an object e(X) in such a way that, for any concepts X, Y satisfying a certain predicate E, we have e (X) = e (Y) iff the same objects fall under X and Y.

MANY-SORTED LOGIC AND ITS APPLICATIONS

Edited by K. Meinke and J. V. Tucker: 397 pp., £39.95, ISBN 0 471 93485 2 (John Wiley, 1993).