一个MC逻辑及其逻辑程序的语义

本文定义了一个多ｃｏｎｔｅｘｔ逻辑结构。ＭＣＯ在几个方面推广了传统的一阶逻辑：每个ｃｏｎｔｅｘｔ相关一个理论；Ｃｏｎｔｅｘｔ间存在ｏｕｔｅｒ关系；     

SQL语言的形式语义

对SQL查询的形式语义的研究有助于形式地证明两条SQL语句是否等价,从而消除了自然语言的二义性。SQL标准对SQL的语义规则进行了定义,但是并没有很好地处理不完全信息问题。文中以中介逻辑谓词演算系统MFM为基础,构造一个形式的三值谓词演算模型EPMC,然后通过语法转化规则把SQL查询转化为EPMC,从而完整地定义了SQL查询的形式语义。     

A Compendium of Continuous Lattices in MIZAR

This paper reports on the MIZAR formalization of the theory of continuous lattices as presented in Gierz et al.: A Compendium of Continuous Lattices, 1980. By a MIZAR formalization we mean a formulation of theorems, definitions, and proofs written in the MIZAR language whose correctness is verified by the MIZAR processor. This effort was originally motivated by the question of whether or not the MIZAR system was sufficiently developed for the task of expressing advanced mathematics. The current state of the formalization – 57 MIZAR articles written by 16 authors – indicates that in principle the MIZAR system has successfully met the challenge. To our knowledge it is the most sizable effort aimed at mechanically checking some substantial and relatively recent field of advanced mathematics. However, it does not mean that doing mathematics in MIZAR is as simple as doing mathematics traditionally (if doing mathematics is simple at all). The work of formalizing the material of the Gierz et al. compendium has (i) prompted many improvements of the MIZAR proof checking system, (ii) caused numerous revisions of the the MIZAR data base, and (iii) contributed to the to do list of further changes to the MIZAR system.     

OCCAM-an overview

The language OCCAM has been developed on the basis of communication and concurrency. OCCAM describes the structure of a system of connected microcomputers. It can also be used to program the individual computers. In addition, OCCAM is a design formalism. Its formal semantics allows a program to be read either as a set of commands or as a predicate in an extension of the predicate calculus. The semantics provides a set of rules for transforming programs.The initial implementation of OCCAM is described. Examples are given of its use in a concurrent system and for program transformation.     

Estimating semantic content: An A priori approach

We present our research into the use of the logical structure of natural language discourse to generate estimates of the quantity of semantic content contained within a passage. These estimates of the degree of meaningfulness are recovered from the logical form of the passage, without actually recovering its meaning or necessitating real understanding. We first consider analysis of statements in the propositional calculus, then consider analysis of the logical structure within propositions, as formalized by the predicate calculus. Along the way, we consider several questions related to logic and meaning and introduce several interesting results. the theory and methodology we develop has potential application to a natural language preprocessor for a priori skimming and the production of abstracts, although for now the input should be specified in logical form, rather than in a natural language.     

HOLMES: A deduction augmented database management system

HOLMES is a database system based on object-relationship concept. The idea of a generalized schema is introduced. A uniform language, based on first order predicate calculus, intended to express both formulas of a generalized schema and users' queries is presented. This high level database language enables one to define a database application as a “theory” expressed by a set of formulas. Possibilities of the presented approach are discussed. Implementation problems are sketched.     

A Full Formalization of SLD-Resolution in the Calculus of Inductive Constructions

This paper presents a full formalization of the semantics of definite programs, in the calculus of inductive constructions. First, we describe a formalization of the proof of first-order terms unification: this proof is obtained from a similar proof dealing with quasi-terms, thus showing how to relate an inductive set with a subset defined by a predicate. Then, SLD-resolution is explicitely defined: the renaming process used in SLD-derivations is made explicit, thus introducing complications, usually overlooked, during the proofs of classical results. Last, switching and lifting lemmas and soundness and completeness theorems are formalized. For this, we present two lemmas, usually omitted, which are needed. This development also contains a formalization of basic results on operators and their fixpoints in a general setting. All the proofs of the results, presented here, have been checked with the proof assistant Coq.     

A view of programming languages as symbiosis of meaning and computations

Function and logic programming languages are understood as terms, resp. formulas, of a first order theory. This theory gives meaning to programs and allows reasoning about programs within full predicate logic possibly using quantifiers and induction. The operational semantics of programming languages is given by deductively restricted subtheories of the meaning theory in such a way that the computation sequences are in a one-to-one correspondence with proofs in subtheories. Moreover, meaning is invariant to computations as everything provable in a subtheory is required to be a theorem of the meaning theory. The questions of deadlocks and termination of programs are thus reduced to the proof-theoretical questions of existence of proofs in the subtheories.     

Experience with Modular Concurrent Programming

This paper summarizes the initial experience with the programming language Concurrent Pascal in the design of three model operating systems. A Concurrent Pascal program consists of modules called processes, monitors, and classes. The compiler checks that the data structures of each module are accessed only by the operations defined in the module. The author emphasizes that the creative aspect of program construction is the initial selection of modules and the connection of them into hierarchical structures. By comparison the detailed implementation of each module is straightforward. The most important result is that it is possible to build a concurrent program of one thousand lines out of one-page modules that can be comprehended at a glance.     

An integral theorem prover and the role of proof planning

An investigation is made into the ways proof planning can enhance the capability of a rule based prover for the theory of integration. The integrals are of the Riemann type and are defined in a way to maximize the theorem proving methods of predicate calculus. Approximately fifty theorems have been proved and several examples are discussed. A major shortcoming was found to be the inability of the system to work with or produce a proof plan. As a result, a planning scheme based on the idea of subgoals or milestones was considered. With user defined plans, there was a substantial increase in performance and capability of the system and, in some cases, proofs which were previously unsuccessful were completed.     

A new mapping between combinatorial proofs and sequent calculus proofs read out from logical flow graphs

Combinatorial proofs are abstract invariants for sequent calculus proofs, similarly to homotopy groups which are abstract invariants for topological spaces. Sequent calculus fails to be surjective onto combinatorial proofs, and here we extract a syntactically motivated closure of sequent calculus from which there is a surjection onto a complete set of combinatorial proofs. We characterize a class of canonical sequent calculus proofs for the full set of propositional tautologies and derive a new completeness theorem for combinatorial propositions. For this, we define a new mapping between combinatorial proofs and sequent calculus proofs, different from the one originally proposed, which explicitly links the logical flow graph of a proof to a skew fibration between graphs of formulas. The categorical properties relating the original and the new mappings are explicitly discussed.     

Heuristics used by HERBY for semantic tree theorem proving

This paper describes a number of heuristics that have been implemented in a program that proves theorems by constructing closed semantic trees. The program is called HERBY. We studied the effectiveness of these heuristics on the Stickel Test Set and found that when HERBY was given two hours to prove each theorem, it was able to prove 78 of the 84 theorems in the set. Constructing semantic trees has been used as a theoretical tool for confirming the unsatisfiability of a set of clauses in first-order predicate calculus; this paper shows that this approach has some practicality as well. This revised version was published online in June 2006 with corrections to the Cover Date.     

The integration of network data base management and problem resolution

The value and nature of a mixed approach to knowledge representation is examined. The mixed approach utilizes data base techniques and expressions in first-order predicate calculus. The nature of a general problem processor that can use information organized according to the mixed approach is discussed and illustrated. The user's language interface with this problem processor is non-procedural and English-like. The utilization of predicate calculus axioms for data integrity and program module management is also explored.     

The design of an interactive program development system for Pascal

A program language can be defined as the language in which computer programs are written, and a programming language as the language used by the programmer to create programs. This paper presents the design of an interactive program development system which uses Pascal as both program and programming language. Principal properties of the system are a complete immediate syntax check, a program-structure oriented editor, incremental compiling techniques, and interactive interpretation and debugging of programs. The syntax check is split into three phases, and the user can change the degree of check wanted. After a change of the program only part of it is recompiled, and only necessary phases of the compiling process are performed.     

HOL-Boogie—An Interactive Prover-Backend for the Verifying C Compiler

Boogie is a verification condition generator for an imperative core language. It has front-ends for the programming languages C# and C enriched by annotations in first-order logic, i.e. pre- and postconditions, assertions, and loop invariants. Moreover, concepts like ghost fields, ghost variables, ghost code and specification functions have been introduced to support a specific modeling methodology. Boogie’s verification conditions—constructed via a wp calculus from annotated programs—are usually transferred to automated theorem provers such as Simplify or Z3. This also comprises the expansion of language-specific modeling constructs in terms of a theory describing memory and elementary operations on it; this theory is called a machine/memory model. In this paper, we present a proof environment, HOL-Boogie, that combines Boogie with the interactive theorem prover Isabelle/HOL, for a specific C front-end and a machine/memory model. In particular, we present specific techniques combining automated and interactive proof methods for code verification. The main goal of our environment is to help program verification engineers in their task to “debug” annotations and to find combined proofs where purely automatic proof attempts fail.     

Real-time refinement in Manna and Pnueli's temporal logic

A refinement calculus for the development of real-time systems is presented. The calculus is based upon a wide-spectrum language called TAM (the Temporal Agent Model), within which both functional and timing properties can be expressed in either abstract or concrete terms. A specification oriented semantics is given for the language. Program development is considered as a refinement process i.e. thecalculation of a structured program from an unstructured specification. An example program is developed.     

A Two-Valued Logic for Properties of Strict Functional Programs Allowing Partial Functions

A typed program logic LMF for recursive specification and verification is presented. It comprises a strict functional programming language with polymorphic and recursively defined partial functions and polymorphic data types. The logic is two-valued with the equality symbol as only predicate. Quantifiers range over the values, which permits inductive proofs of properties. The semantics is based on a contextual (observational) semantics, which gives a consistent presentation of higher-order functions. Our analysis also sheds new light on the the role of partial functions and loose specifications. It is also an analysis of influence of extensions of programs on the tautologies. The main result is that universally quantified equations are conservative, which is also the base for several other conservative classes of formulas.     

A theory of bunches

A bunch is a simple data structure, similar in many respects to a set. However, bunches differ from sets in that the data is not packaged up or encapsulated, and in particular in that a bunch consisting of one element is the same as that element. Bunches are attractive for handling nondeterminacy and underspecification, by which is meant that for any particular input to the program or specification, the associated output is not fully determined. The acceptable outputs for any given input can be described by a bunch. This approach nicely generalises traditional single-output programs and specifications. We present a formal theory of bunches. It includes an axiomatisations of boolean and function types whose behaviour is well-known to be complicated by the presence of nondeterminacy. The axiomatisation of the booleans preserves most of the laws of classical predicate calculus. The axiomatisation of functions accommodates higher-order functions in all their generality, while avoiding the dangers of inconsistency when functions and nondeterminacy intermix. Our theory is presented as a Hilbert-style system of axioms and inference rules for a small specification language. We prove consistency. Received: 23 December 1998 / 2 November 1999     

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 least reflective Herbrand model of P, characterized by means of a suitable mapping defined over the Herbrand interpretations of P. The extended resolution is proved sound and complete with respect to the least reflective Herbrand model. By illustrating Reflective Prolog solutions to an organic set of problems, and by discussing the main differences with respect to other approaches to logic metaprogramming, we show that the proposed language deploys, within its field of action, greater expressive and inferential power than those available till now. The interpreter of the language has been fully implemented. Because of its enhanced power, logic semantics and working interpreter, Reflective Prolog is offered as a contribution toward making the declarative approach of logic programming applicable to the development of increasingly sophisticated knowledge-based systems.