Higher-order Predicates Research Articles

Predykaty wyższego vs. pierwszego rzędu jako problem syntaktyczny

HIGHER-ORDER VS FIRST-ORDER PREDICATES AS A SYNTACTIC PROBLEM The author considers the problems of syntactic analysis of language expressions with higher-order and first-order predicates. In the first part it is shown that there are some discrepancies in the treatment of these categories: on the one hand, in semantic syntax, and, on the other hand, in predicate logic and in categorial grammar. In the following chapters, the author analyses the disputed phenomena that can be treated in two ways, depending on whether the verb is considered a first-order or higher-order predicate. At the same time, it is stated that the valence properties of a verb depend on its lexical meaning, and, on the other hand, the definition of meaning should take into account the nature of the syntactic structure. The notion of precedent representations is suggested, i. e. constructions with a clausal actant that indicate the propositional status of the appropriate complements of the predicate.

What Is Existence?

This paper has a negative and a positive claim. The negative claim is that the Frege-Russell account of existence as a higher-order predicate is mistaken and should be abandoned, even with respect to general statements of existence such as “Flying mammals exist” (where statements of this sort are supposed to be best accommodated by the account). The Frege-Russell view seems to be supported by two ideas. First, the idea that existence is entirely expressed by the existential quantifier of standard predicate logic. Second, the idea that the existential quantifier is a higher-order predicate, a predicate of predicates, not of individuals. I think that both ideas are wrong but will focus on the latter. By construing prima facie first-order statements such as “Flying Mammals exist” as higher-order predications such as “The Fregean Concept Flying Mammal maps at least one individual onto the True”, the Frege-Russell view commits one merely on the basis of the meaning it assigns to the existence predicate – to abstract objects such as concepts (Gottlob Frege), or propositional functions (Bertrand Russell), or classes (Rudolf Carnap), or properties, kinds, and so on. This cannot be right, I think. The positive claim of the present paper is that, at least in the context of first-order discourse, the existence predicate is just what it seems to be: a bona fide first-order predicate (pace Kant, Hume, Frege, Russell and others). Three important ideas about existence are shared with the Frege-Russell conception of existence, though.

Introduction to the special issue on Prolog systems

It has now been 40 years since the birth of the Prolog language and of its first implementation by A. Colmerauer and P. Roussel. Since then, a large number of Prolog systems have been implemented. While the core of the Prolog language has not changed much in these 40 years, Prolog systems have undergone an extraordinary evolution that stems from two main sources. One is the trend to extend Prolog to incorporate ideas from other language paradigms that have proved useful in real-world applications. This includes concurrency, parallelism, higher order predicates, object-oriented programming, Web interfaces, processing of large amounts of data, and flexible developer tools that enhance reliability and robustness through assertions. A second source of change is the exploration of ideas for which Prolog systems are uniquely suitable and that have led to the creation of new programming paradigms. This includes tabling, constraint logic programming, answer set programming, and probabilistic logic programming.

Checking modes of HAL programs

Recent constraint logic programming (CLP) languages, such as HAL and Mercury, require type, mode and determinism declarations for predicates. This information allows the generation of efficient target code and the detection of many errors at compile-time. Unfortunately, mode checking in such languages is difficult. One of the main reasons is that, for each predicate mode declaration, the compiler is required to appropriately re-order literals in the predicate's definition. The task is further complicated by the need to handle complex instantiations (which interact with type declarations and higher-order predicates) and automatic initialization of solver variables. Here we define mode checking for strongly typed CLP languages which require reordering of clause body literals. In addition, we show how to handle a simple case of polymorphic modes by using the corresponding polymorphic types.

Solving constraint optimization problems from CLP-style specifications using heuristic search techniques

Presents a framework for efficiently solving logic formulations of combinatorial optimization problems using heuristic search techniques. In order to integrate cost, lower-bound and upper-bound specifications with conventional logic programming languages, we augment a constraint logic programming (CLP) language with embedded constructs for specifying the cost function and with a few higher-order predicates for specifying the lower and upper bound functions. We illustrate how this simple extension vastly enhances the ease with which optimization problems involving combinations of Min and Max can be specified in the extended language CLP* and we show that CSLDNF (Constraint SLD resolution with Negation as Failure) resolution schemes are not efficient for solving optimization problems specified in this language. Therefore, we describe how any problem specified using CLP* can be converted into an implicit AND/OR graph, and present an algorithm called GenSolve which can branch-and-bound using upper and lower bound estimates, thus exploiting the full pruning power of heuristic search techniques. A technical analysis of GenSolve is provided. We also provide experimental results comparing various control strategies for solving CLP* programs.

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

Programming in Three Dimensions

Cube is a three-dimensional, visual, statically typed, higher-order logic programming language, designed to be used in a virtual-reality-based programming environment. In this paper, we give an informal overview of the language and describe a prototype implementation.

Higher-order quantum logics

Until now quantum logics has been first-order, but physics requires higher-order logics. We construct a natural higher-order languageQ for quantum physics.Q is a finitistic logic based on Peano set theory and Grassmann algebra. Higher-order predicates are identified with their extensions, higher-rank sets. QAND and QOR (the AND and OR ofQ) are naturally noncommutative but reduce to the commutative lattice operations for the first-order part of the language. We form higher-order predicates and sets by a setting operator similar to Peano'st that forms a simple extensort Ψ = }Ψ} from any extensorΨ. In a note added in proof, we correctQ so that a bond like {{α, β}} between two fermionsα andβ is a quasiboson, as the application to lattice chromodynamics strongly suggests.

The transparent PROLOG machine (TPM): an execution model and graphical debugger for logic programming

An augmented and⧸ or tree representation of logic programs is presented as the basis for an advanced graphical tracing and debugging facility for PROLOG. An extension of our earlier work on “retrospective zooming”, this representation offers several distinct advantages over existing tracing and debugging facilities: (1) it naturally incorporates traditional and⧸ or trees and Byrd box models (call⧸exit⧸fail⧸redo procedural models) as special cases; (2) it can be run in slow-motion, close-up mode for novices or high-speed, long-distance mode for experts with no attendant conceptual change; (3) it serves as the uniform basis for textbook material, video-based teaching material, and an advanced user interface for experienced PROLOG programmers; (4) it tells the truth about clause head matching and deals correctly with the cut. One of the key insights underlying the work is the realization that it is possible to display an execution space of several thousand nodes in a meaningful way on a modern graphics workstation. By enhancing and⧸ or trees to include “status boxes” rather than simple “nodes”, it is possible to display both a long-distance view of execution and the full details of clause-head matching. Graphical “collapsing” techniques enable the model to deal with user-defined abstractions, higher-order predicates such as setof, and definite-clause grammars. The current implementation runs on modern graphics workstations and is written in PROLOG.

Set abstraction—An extension of all solutions predicate in logic programming language

The concept of set abstraction is introduced as a simple analogy of that of lambda abstraction in the theory of lambda calculus. The set abstraction is concerned with two extensions concerning Prolog language features: “set expression” and “predicate variable.” It has been argued in the literature that the set expression extension to Prolog does really contribute to the power of the language, while the extension of predicate variables does not add anything to Prolog. Combining these two concepts of extensions to Prolog, we define “set abstraction” as the set expression in which predicate variables are allowed as data objects. In other words, the set abstraction gets involved in the higher order predicate logic. By showing some application examples, it is demonstrated that with the help of predicate variables set abstractions can nicely handle the issues of the second order predicate logic. Further, the implementation programs written in Prolog and Concurrent Prolog are presented.

Coherent quantum logic

The von Neumann quantum logic lacks two basic symmetries of classical logic, that between sets and classes, and that between lower and higher order predicates. Similarly, the structural parallel between the set algebra and linear algebra of Grassmann and Peano was left incomplete by them in two respects. In this work a linear algebra is constructed that completes this correspondence and is interpreted as a new quantum logic that restores these invariances, and as a quantum set theory. It applies to experiments with coherent quantum phase relations between the quantum and the apparatus. The quantum set theory is applied to model a Lorentz-invariant quantum time-space complex.

A one axiom set theory based on higher order predicate calculus

A one axiom set theory based on higher order predicate calculus

Epistemic foundations of logic

The foundations of logic should be obvious and compelling. They should at least explain why we may not deny the tautologies of this or that logical system, if we are to have a rational systen of beliefs. I believe that standard semantics helps to explain why the tautologies of the sentential calculus and lower predicate calculus should not be rejected but does little to explain why those of higher order predicate calculus and of modal sentential and predicate calculi may not be denied. I do not propose to argue here that this is so. I wish only to show how a foundation of a different kind can succeed in doing simply and elegantly what I claim standard semantics fails to do. By standard semantics I mean the kind of semantics which can be found in almost any textbook on logic in which the logical connectives and operators of a formally (syntactically) defined language-structure are defined in terms of truth and falsity conditions. I shall call any such foundation for a logical system a truth semantics. The need for a truth semantics derives from the standard concept of validity of argument according to which an argument is valid iff there is no interpretation of its non-logical terms, (or alternatively, no possible world) in which its premises are true and its conclusion false. For it follows from this definition that to understand any sentence sufficiently for all of the purposes of logic we need to know under what interpretations (or in what possible worlds) it would be true or false. I proceed from a different concept of validity, which leads to a different programme of analysis, and hence to a different kind of foundation for logical systems. I consider an argument in a given language to be valid iff there is no rational belief system on that language in which its premises are accepted and its conclusion rejected. Thus, for me, validity is an epistemic notion, and my problem is to define a rational belief system on a language, and to specify acceptance and rejection conditions for the sentences of that language. I begin in the usual way be defining a language-structure syntactically, so that the sentences, operators, connectives, etc. of the language-structure can