Predicate Language Research Articles

Verified lifting of stencil computations

This paper demonstrates a novel combination of program synthesis and verification to lift stencil computations from low-level Fortran code to a high-level summary expressed using a predicate language. The technique is sound and mostly automated, and leverages counter-example guided inductive synthesis (CEGIS) to find provably correct translations. Lifting existing code to a high-performance description language has a number of benefits, including maintainability and performance portability. For example, our experiments show that the lifted summaries can enable domain specific compilers to do a better job of parallelization as compared to an off-the-shelf compiler working on the original code, and can even support fully automatic migration to hardware accelerators such as GPUs. We have implemented verified lifting in a system called STNG and have evaluated it using microbenchmarks, mini-apps, and real-world applications. We demonstrate the benefits of verified lifting by first automatically summarizing Fortran source code into a high-level predicate language, and subsequently translating the lifted summaries into Halide, with the translated code achieving median performance speedups of 4.1X and up to 24X for non-trivial stencils as compared to the original implementation.

Invisible Things and Unnoticed Expanses

The social world and the private world are most clearly demarcated when it comes to what is most intimately one’s own, namely the things that others cannot, even in principle, possess. Among the things others cannot possess is one’s own field of vision, where the obstacle to another having it, and thereby appreciating it, simply lies in the fact that two human beings cannot occupy the same visual perspectives continuously throughout their lives. Even more intimately one’s own are the things one sees that no other can, even if another managed to occupy one’s visual perspective on the world. This essay is an exploration of those things, so-called “pure visibilia,” focusing on the question of whether those putative items can be discharged in favor of a common visual language of predicates, true or false, of publicly viewable objects. The conclusion is that they cannot be discharged in this way. The important theoretical question is: what does this mean for the theory of vision?

Justifying Objective Bayesianism on Predicate Languages

Objective Bayesianism says that the strengths of one’s beliefs ought to be probabilities, calibrated to physical probabilities insofar as one has evidence of them, and otherwise sufficiently equivocal. These norms of belief are often explicated using the maximum entropy principle. In this paper we investigate the extent to which one can provide a unified justification of the objective Bayesian norms in the case in which the background language is a first-order predicate language, with a view to applying the resulting formalism to inductive logic. We show that the maximum entropy principle can be motivated largely in terms of minimising worst-case expected loss.

An Exact Correspondence of Linear Problems and Randomizing Linear Algorithms

A linear problem is completely solved by a randomizing linear algorithm if the set of data-solution pairs of the problem equals the set of input–output pairs of the algorithm over all randomizations. Linear problems are based on the predicate language over ordered fields. This class contains, for example, all linear programs, all bounded variable integer programs, all satisfiability problems in sentential logic, and models of conflict. Randomizing linear algorithms are based on a tree, arithmetic, comparisons, and random selections, over ordered fields, and with a restriction on certain operations. We show that the correspondence “completely solved by” is one-to-one and onto from equivalences of linear problems to equivalences of randomizing linear algorithms. †1947–2012.

Some artificial intelligence problems permitting formalization by means of predicate calculus language and upper bounds of their solution steps

Some artificial intelligence problems including such ones as pattern recognition, medical diagnostics, market analysis is reduced to the proof of satisfi\-abi\-li\-ty of predicate calculus formulas with a symple structure. Some algorithms solving such problems are regarded and the upper bounds of their steps are proved.

Predicate abstraction in Java Pathfinder

We present our ongoing effort to implement predicate abstraction in Abstract Pathfinder, which is an extension of Java Pathfinder. Our approach builds upon existing abstraction techniques that have been proposed mainly for low-level programs in C. We support predicates over variables having numerical data types. The main challenges that we have addressed include (1) the design of the predicate language, (2) support for arrays, (3) finding predicates affected by a given statement, (4) aliasing between variables, (5) propagating values of predicates over method call boundaries, and (6) computing weakest preconditions for complex predicates. We describe our solution to these challenges and selected details about the implementation. We also discuss our future plans and research ideas.

Some remarks on formal description of God's omnipotence

There are proposed two simple formal descriptions of the notion of God’s omnipotence which are inspired by formalizations of C. Christian and E. Nieznański. Our first proposal is expressed in a modal sentential language with quantifires. The second one is formulated in first order predicate language. In frame of the second aproach we admit using self-referential expressions. In effect we link our considerations with so called paradox of God’s omnipotence and reconstruct some argumentation against the possibility of reference God’s omnipotence to a lack of itself.

Noninterference in a predicative polymorphic calculus for access control

Polymorphic programming languages have been adapted for constructing distributed access control systems, where a program represents a proof of eligibility according to a given policy. As a security requirement, it is typically stated that the programs of such languages should satisfy noninterference. However, this property has not been defined and proven semantically. In this paper, we first propose a semantics based on Henkin models for a predicative polymorphic access control language based on lambda-calculus. A formal semantic definition of noninterference is then proposed through logical relations. We prove a type soundness theorem which states that any well-typed program of our language meets the noninterference property defined in this paper. In this way, it is guaranteed that access requests from an entity do not interfere with those from unrelated or more trusted entities.

Predicate abstraction of Java programs with collections

Our goal is to develop precise and scalable verification techniques for Java programs that use collections and properties that depend on their content. We apply the popular approach of predicate abstraction to Java programs and collections. The main challenge in this context is precise and compact modeling of collections that enables practical verification. We define a predicate language for modeling the observable state of Java collections at the interface level. Changes of the state by API methods are captured by weakest preconditions. We adapt existing techniques for construction of abstract programs. Most notably, we designed optimizations based on specific features of the predicate language. We evaluated our approach on Java programs that use collections in advanced ways. Our results show that interesting properties, such as consistency between multiple collections, can be verified using our approach. The properties are specified using logic formulas that involve predicates introduced by our language.

Logical inference techniques for loop parallelization

This paper presents a fully automatic approach to loop parallelization that integrates the use of static and run-time analysis and thus overcomes many known difficulties such as nonlinear and indirect array indexing and complex control flow. Our hybrid analysis framework validates the parallelization transformation by verifying the independence of the loop's memory references. To this end it represents array references using the USR (uniform set representation) language and expresses the independence condition as an equation, S =0, where S is a set expression representing array indexes. Using a language instead of an array-abstraction representation for S results in a smaller number of conservative approximations but exhibits a potentially-high runtime cost. To alleviate this cost we introduce a language translation F from the USR set-expression language to an equally rich language of predicates ( F ( S ) ==> S = 0). Loop parallelization is then validated using a novel logic inference algorithm that factorizes the obtained complex predicates (F( S )) into a sequence of sufficient independence conditions that are evaluated first statically and, when needed, dynamically, in increasing order of their estimated complexities. We evaluate our automated solution on 26 benchmarks from PERFECT-Club and SPEC suites and show that our approach is effective in parallelizing large, complex loops and obtains much better full program speedups than the Intel and IBM Fortran compilers.

Verification and synthesis of addition programs under the rules of correctness of statements

Deductive verification and synthesis of binary addition programs are carried out on the base of the rules of proving the correctness for statements of the predicate programming language P. The paper presents key fragments of verification and synthesis of the programs for the Ripple carry, Carry look-ahead and Ling adders. The correctness conditions of the programs were translated into the specification language of the PVS verification system. The proof is found to be a tedious procedure as compared with the ordinary programming. However, for program synthesis, the development of theories and proofs on PVS are easier and faster than for program verification.

Preserving mappings in fuzzy predicate logics

In this article, we develop the method of diagrams for fuzzy predicate logics and give a characterization of different kinds of preserving mappings in terms of diagrams. Our work is a contribution to the model-theoretic study of fuzzy predicate logics. We present a reduced semantics and we prove a completeness theorem of the logics with respect to this semantics. The main concepts being studied are the Leibniz congruence and the structure-preserving relation. On the one hand, the Leibniz congruence of a model identifies the elements that are indistinguishable using equality-free atomic formulas and parameters from the model. A reduced structure is the quotient of a model modulo this congruence. On the other hand, the structure-preserving relation between two structures plays the same role that the isomorphism relation plays in classical predicate languages with equality.

Impact of XML Schema Evolution

We consider the problem of XML Schema evolution. In the ever-changing context of the web, XML schemas continuously change in order to cope with the natural evolution of the entities they describe. Schema changes have important consequences. First, existing documents valid with respect to the original schema are no longer guaranteed to fulfill the constraints described by the evolved schema. Second, the evolution also impacts programs, manipulating documents whose structure is described by the original schema. We propose a unifying framework for determining the effects of XML Schema evolution both on the validity of documents and on queries. The system is very powerful in analyzing various scenarios in which forward/backward compatibility of schemas is broken, and in which the result of a query may no longer be what was expected. Specifically, the system offers a predicate language that allows one to formulate properties related to schema evolution. The system then relies on exact reasoning techniques to perform a fine-grained analysis. This yields either a formal proof of the property or a counter-example that can be used for debugging purposes. The system has been fully implemented and tested with real-world use cases, in particular with the main standard document formats used on the web, as defined by W3C. The system precisely identifies compatibility relations between document formats. In case these relations do not hold, the system can identify queries that must be reformulated in order to produce the expected results across successive schema versions.

Efficient event processing through reconfigurable hardware for algorithmic trading

In this demo, we present fpga-ToPSS (Toronto Publish/Subscribe System Family), an efficient event processing platform for high-frequency and low-latency algorithmic trading. Our event processing platform is built over reconfigurable hardware---FPGAs---to achieve line-rate processing. Furthermore, our event processing engine supports Boolean expression matching with an expressive predicate language that models complex financial strategies to autonomously buy and sell stocks based on real-time financial data.

Fuzzy Description Logics and t-norm based fuzzy logics

Description Logics (DLs) are knowledge representation languages built on the basis of classical logic. DLs allow the creation of knowledge bases and provide ways to reason on the contents of these bases. Fuzzy Description Logics (FDLs) are natural extensions of DLs for dealing with vague concepts, commonly present in real applications. Hájek proposed to deal with FDLs taking as basis t-norm based fuzzy logics with the aim of enriching the expressive possibilities in FDLs and to capitalize on recent developments in the field of Mathematical Fuzzy Logic. From this perspective we define a family of description languages, denoted by ALC ∗ ( S ) , which includes truth constants for representing truth degrees. Having truth constants in the language allows us to define the axioms of the knowledge bases as sentences of a predicate language in much the same way as in classical DLs. On the other hand, taking advantage of the expressive power provided by these truth constants, we define a graded notion of satisfiability, validity and subsumption of DL concepts as the satisfiability, validity and subsumption of evaluated formulas. In the last section we summarize some results concerning fuzzy logics associated with these new description languages, we analyze aspects relative to general and canonical semantics, and we prove some results relative to canonical standard completeness for some FDLs considered in the paper.

Identifying query incompatibilities with evolving XML schemas

During the life cycle of an XML application, both schemas and queries may change from one version to another. Schema evolutions may affect query results and potentially the validity of produced data. Nowadays, a challenge is to assess and accommodate the impact of these changes in evolving XML applications. Such questions arise naturally in XML static analyzers. These analyzers often rely on decision procedures such as inclusion between XML schemas, query containment and satisfiability. However, existing decision procedures cannot be used directly in this context. The reason is that they are unable to distinguish information related to the evolution from information corresponding to bugs. This paper proposes a predicate language within a logical framework that can be used to make this distinction. We present a system for monitoring the effect of schema evolutions on the set of admissible documents and on the results of queries. The system is very powerful in analyzing various scenarios where the result of a query may not be anymore what was expected. Specifically, the system is based on a set of predicates which allow a fine-grained analysis for a wide range of forward and backward compatibility issues. Moreover, the system can produce counterexamples and witness documents which are useful for debugging purposes. The current implementation has been tested with realistic use cases, where it allows identifying queries that must be reformulated in order to produce the expected results across successive schema versions.

Homogeneous and strictly homogeneous criteria for partial structures

The Galois closure on the set of relations invariant to all finite partial automorphisms (automorphisms) of a countable partial structure is established via quantifier-free infinite predicate languages (infinite languages with finite string of quantifiers respectively). Based on it the homogeneous and strictly homogeneous criteria for a countable partial structure as well as an ultrahomogeneous criterion for a countable relational structure are found. Next it is shown that infinite languages with a finite string of quantifiers cannot determine the corresponding Galois closure for relations invariant to all automorphisms of an uncountable partial structure.

Objective Bayesian probabilistic logic

This paper develops connections between objective Bayesian epistemology—which holds that the strengths of an agent's beliefs should be representable by probabilities, should be calibrated with evidence of empirical probability, and should otherwise be equivocal—and probabilistic logic. After introducing objective Bayesian epistemology over propositional languages, the formalism is extended to handle predicate languages. A rather general probabilistic logic is formulated and then given a natural semantics in terms of objective Bayesian epistemology. The machinery of objective Bayesian nets and objective credal nets is introduced and this machinery is applied to provide a calculus for probabilistic logic that meshes with the objective Bayesian semantics.

Objective Bayesianism with predicate languages

Objective Bayesian probability is often defined over rather simple domains, e.g., finite event spaces or propositional languages. This paper investigates the extension of objective Bayesianism to first-order logical languages. It is argued that the objective Bayesian should choose a probability function, from all those that satisfy constraints imposed by background knowledge, that is closest to a particular frequency-induced probability function which generalises the λ = 0 function of Carnap’s continuum of inductive methods.

The ontology of intentionality II: dependence ontology as prolegomenon to noetic modal semantics

This is the second in a sequence of three essays which axiomatize and apply Edmund Husserl's dependence ontology of parts and wholes as a non-Diodorean, non-Kantian temporal semantics for first-order predicate modal languages. The Ontology of Intentionality I introduced enough of Husserl's dependence-ontology of parts and wholes to formulate his account of order as effected by relating moments of unity, and The Ontology of Intentionality II extends that axiomatic dependence-ontology far enough to enable its semantic application. Formalizing the compatibility [Vereinbarkeit] relation implicated in Husserl's notorious doctrine of impossible meanings, the essay introduces a compatibility restriction on relations to formulate Husserl's distinction between singular [einheitliche] and plural [mehrheitliche] objects, using plural relating moments to define first-order versions of Husserl's notions of relation complexes (i.e. Sachverhalte), abstracta of n-ary relation complexes, categorial relations, abstract eide as unifications of categorial relations, semantic domains as completions of abstract eide, and material regions as semantic domains which are compatibility upper bounds of categorial relations. These concepts will enable the formal dependence-ontological noetic semantics for two-valued, first-order modal languages introduced in the sequel Two-Valued Logics of Intentionality, the third essay in the sequence.