14544430
Specifying Theorem Provers in a Higher-Order Logic Programming Language
Since logic programming systems directly implement search and unification and since these operations are essential for the implementation of most theorem provers, logic programming languages should make ideal implementation languages for theorem provers. We shall argue that this is indeed the case if the logic programming language is extended in several ways. We present an extended logic programming language where first-order terms are replaced with simply-typed λ-terms, higher-order unification replaces first-order unification, and implication and universal quantification are allowed in queries and the bodies of clauses. This language naturally specifies inference rules for various proof systems. The primitive search operations required to search for proofs generally have very simple implementations using the logical connectives of this extended logic programming language. Higher-order unification, which provides sophisticated pattern matching on formulas and proofs, can be used to determine when and at what instance an inference rule can be employed in the search for a proof. Tactics and tacticals, which provide a framework for high-level control over search, can also be directly implemented in this extended language. The theorem provers presented in this paper have been implemented in the higher-order logic programming language λProlog.
10134130
A Congruence Format for Name-passing Calculi
We define and use a SOS-based framework to specify the transition systems of calculi with name-passing properties. This setting uses proof-theoretic tools to take care of some of the difficulties specific to name-binding and make them easier to handle in proofs. The contribution of this paper is the presentation of a format that ensures that open bisimilarity is a congruence for calculi specified within this framework, extending the well-known tyft/tyxt format to the case of name-binding and name-passing. We apply this result to the @p-calculus in both its late and early semantics.
100764
Foundational aspects of syntax
A large variety of computing systems, such as compilers, interpreters, static analyzers, and theorem provers, need to manipulate syntactic objects like programs, types, formulas, and proofs. A common characteristic of these syntactic objects is that they contain variable binders, such as quantifiers, scoping operators, and parameters. The presence of binders complicates formal specifications and symbolic processing. Consider, for example, a function definition of the form
5278164
A Logic Programming Approach to Manipulating Formulas and Programs
By permitting function and predicate symbols to be variables and by replacing first-order terms by simply typed $lambda$-terms, a higher-order extension to first-order Horn clauses can be described. To be complete in principle, a logic programming language based on this extension must incorporate higher-order unification. Although this is a more complex operation than first-order unification, its availability as a primitive makes certain kinds of programming tasks easier. We illustrate this aspect in the paper by presenting some programs in a higher-order version of Prolog called $\lambda$Prolog that manipulate objects, such as formulas and programs, whose representation requires structures containing abstractions or bound variables. Specifically, we show (a) how a simple natural deduction theorem prover may be implemented in $\lambda$Prolog, and (b) how some simple program transformers for a functional programming language may be written in this language. These programs exploit the availability of $\lambda$-conversion and higher-order unification in $\lambda$Prolog to provide elegant solutions to several awkward problems inherent in these tasks. We contend that programs which perform similar tasks but which are written in languages without these features would, at least, be much less perspicuous.
8816413
Uses of Higher-Order Unification for Implementing Program Transformers
Source-to-source program transformers belong to the class of meta-programs that manipulate programs as objects. It has previously been argued that a higher-order extension of Prolog, such as λProlog, makes a suitable implementation language for such meta-programs. In this paper, we consider this claim in more detail. In λProlog, object-level programs and program schemata can be represented using simply typed λ-terms and higher-order (functional) variables. Unification of these λ-terms, called higher-order unification, can elegantly describe several important meta-level operations on programs. We detail some properties of higher-order unification that make it suitable for analyzing program structures. We then present (in λProlog) the specification of several simple program transformers together with a more involved partial evaluator. With the depth-first control strategy of λProlog for both clause selection and unifier selection all the above mentioned specifications can be and have been executed and tested. Comments University of Pennsylvania Department of Computer and Information Science Technical Report No. MSCIS-88-46. This technical report is available at ScholarlyCommons: http://repository.upenn.edu/cis_reports/698 USES OF HIGHER-ORDER UNIFICATION FOR IMPLEMENTING PROGRAM TRANSFORMERS JohnHannan Dale Miller MS-CIS-88-46 LlNC LAB 118 Department of Computer and Information Science School of Engineering and Applied Science University of Pennsylvania Philadelphia, PA 19104
32145280
Logical foundations for open system design
27853952
A non-greedy approach to tree-structured clustering
Abstract We propose a new interdisciplinary approach for the hard optimization problem of tree-structured clustering, wherein the imposition of structural constraints on the solution drastically reduces the complexity of classifying data. The method, derived with analogy to statistical physics, performs a global optimization over the entire tree. Experimentation with non-trivial examples shows that our approach consistently outperforms greedy methods and avoids local minima that may trap them.
39731578
On multiplicative graphs and the product conjecture
We study the following problem: which graphsG have the property that the class of all graphs not admitting a homomorphism intoG is closed under taking the product (conjunction)? Whether all undirected complete graphs have the property is a longstanding open problem due to S. Hedetniemi. We prove that all odd undirected cycles and all prime-power directed cycles have the property. The former result provides the first non-trivial infinite family of undirected graphs known to have the property, and the latter result verifies a conjecture of Nešetřil and Pultr These results allow us (in conjunction with earlier results of Nešetřil and Pultr [17], cf also [7]) to completely characterize all (finite and infinite, directed and undirected) paths and cycles having the property. We also derive the property for a wide class of 3-chromatic graphs studied by Gerards, [5].
657782
Experiences with an Architecture for Intelligent, Reactive Agents
This paper briefly describes a robot architecture that has been under development for the last eight years. This architecture uses several levels of abstraction and description languages that are compatible between levels. The makeup of the architecture helps to coordinate planful activities with real-time behaviors for dealing with dynamic environments. In recent years, many architectures have been created with similar attributes. The two features that distinguish this architecture from most of those are: 1) a variety of useful software tools have been created to help implement this architecture on multiple real robots; and 2) this architecture, or parts of it have been implemented on over half a dozen very different robot systems using a variety of processors, operating systems, effectors and sensor suites.
16186126
Representing and Reasoning with Operational Semantics
The operational semantics of programming and specification languages is often presented via inference rules and these can generally be mapped into logic programming-like clauses. Such logical encodings of operational semantics can be surprisingly declarative if one uses logics that directly account for term-level bindings and for resources, such as are found in linear logic. Traditional theorem proving techniques, such as unification and backtracking search, can then be applied to animate operational semantic specifications. Of course, one wishes to go a step further than animation: using logic to encode computation should facilitate formal reasoning directly with semantic specifications. We outline an approach to reasoning about logic specifications that involves viewing logic specifications as theories in an object-logic and then using a meta-logic to reason about properties of those object-logic theories. We motivate the principal design goals of a particular meta-logic that has been built for that purpose.
1440056
Concerning the achromatic number of graphs
Abstract The achromatic number of a graph G is the largest number of colors that can be assigned to the vertices of G so that (i) adjacent vertices are assigned different colors, and (ii) any two different colors are assigned to some pair of adjacent vertices. We study the achromatic number from the point of view of computational complexity. We show that, for each fixed integer n , there is an algorithm which, for an arbitrary graph G , determines in time O (| E ( G )|) whether the achromatic number of G is at least n . In contrast to this, we show that when n is part of the input, the problem is NP-complete even when restricted to bipartite graphs. The complexity of determining the achromatic number of a tree is unknown. We present polynomial algorithms to solve this problem for several classes of trees, and provide upper bounds on the achromatic number of a tree in terms of the maximum degree and the number of edges.