Hai-Feng Guo

Online Justification for Tabled Logic Programs

Justification is the process of constructing evidence, in terms of proof, for the truth or falsity of an answer derived by tabled evaluation. The evidence is most easily constructed by post-processing the memo tables created during query evaluation. In this paper we introduce online justification, based on program transformation, to efficiently construct the evidence during query evaluation, while adding little overhead to the evaluation itself. Apart from its efficiency, online justification separates evidence generation from exploration thereby providing flexibility in exploring the evidence either declaratively or procedurally. We present experimental results obtained on examples that construct large evidences which demonstrate the scalability of online justification.

UMA: a system for universal mathematics accessibility

We describe the UMA system, a system developed under a multi-institution collaboration for making mathematics universally accessible. The UMA system includes translators that freely inter-convert mathematical documents transcribed in formats used by unsighted individual (Nemeth, Marburg) to those used by sighted individuals (LaTeX, Math-ML, OpenMath) and vice versa. The UMA system also includes notation-independent tools for aural navigation of mathematics. In this paper, we give an overview of the UMA system and the techniques used for realizing it.

Speculative Beats Conservative Justification

Justifying the truth value of a goal resulting from query evaluation of a logic program corresponds to providing evidence, in terms of a proof, for this truth. In an earlier work we introduced the notion of justification [8] and gave an algorithm for justifying tabled logic programs by post-processing the memo tables created during evaluation. A conservatve justifier such as the one described in that work proceeds in two separate stages: evaluate the truth of literals (that can possibly contribute to the evidence) in the first stage and construct the justification in the next stage. Justifications built in this fashion seldom fail. Whereas for tabled predicates evaluation amounts to a simple table look-up during justification, for non-tabled predicates this amounts to Prolog-style re-execution. In a conservative justifier a non-tabled literal can be re-executed causing unacceptable performance overheads for programs with significant nontabled components: justification time for a single non-tabled literal can become quadratic in its evaluation time!In this paper we introduce the concept of a speculative justifier. In such a justifier we evaluate the truths of literals in tandem with justification. Specifically, we select literals that can possibly provide evidence for the goals truth, assume that their truth values correspond to the goals and proceed to build a justification for each of them. Since these truths are not computed before hand, justfications produced in this fashion may fail often. On the other hand non-tabled literals are re-executed less often than conservative justifiers. We discuss the subtle efficiency issues that arise in the construction of speculative justifiers. We show how to judiciously balance the different efficiency concerns and engineer a speculative justifier that addresses the performance problem associated with conservative justifiers. We provide experimental evidence of its efficiency and scalability in justifying the results of our XMC model checker.

A methodology for order-sensitive execution of non-deterministic languages on Beowulf platforms

We propose a novel methodology, based on stack splitting, to efficiently support order-sensitive computations (e.g., I/O, side-effects) during search-parallel execution of non-deterministic languages on Beowulf platforms. The methodology has been validated in the context of the PALS Prolog system and results on a Pentium Beowulf are discussed.

PALS: An Or-Parallel Implementation of Prolog on Beowulf Architectures

This paper describes the development of the PALS system, an implementation of Prolog that efficiently exploits or-parallelism on share-nothing platforms. PALS makes use of a novel technique, called incremental stack-splitting. The technique builds on the stack-splitting approach, which in turn is an evolution of the stack-copying method used in a variety of parallel logic systems. This is the first distributed implementation based on the stack-splitting method ever realized. Experimental results obtained on a Beowulf system are presented and analyzed.

Winsight: towards completely automatic backtranslation of Nemeth code

We present the Winsight system, a Windows-based software system for completely automatic translation of Nemeth Braille code to LATEX. The Winsight system takes hard copy Braille input containing Mathematics (written in Nemeth Braille code) and text (written in contracted Braille) via a scanner, performs image recognition and analysis of the scanned file to generate the ASCII Braille file, automatically separates Nemeth Braille coded expressions and contracted Braille text, backtranslates them to LATEX math expressions and LATEX text respectively, and produces a print output file in pdf format containing the result of backtranslation. The Winsight system comes with tools that allow users to manually intervene during each step, if they desire, to fix any errors reported by the system or seen by the user. In this paper we give an overview of the Winsight system.

Logic programming with solution preferences

Abstract Preference logic programming (PLP) is an extension of logic programming for declaratively specifying problems requiring optimization or comparison and selection among alternative solutions to a query. PLP essentially separates the programming of a problem itself from the criteria specification of its solution selection. In this paper we present a declarative method for specifying preference logic programs. The method introduces a precise formalization for the syntax and semantics of PLP. The syntax of a preference logic program contains two disjoint sets of definite clauses, separating a core program specifying a general computational problem from its preference rules for optimization; the semantics of PLP is given based on the Herbrand model and fixed point theory, where how preferences affects the least Herbrand model of a logic program is interpreted as a sequence of meta-level mapping operations. In addition, we present an operational semantics based on a new resolution strategy and a memoized recursive algorithm for computing strictly stratified logic programs with well-formed preferences, and further show that the operational semantics of such a preference logic program is consistent to its declarative semantics.

Semantics-Based Filtering: Logic Programming's Killer App?

We present a logic programming based framework for rapidly translating one formal notation Ls to another formal notation Lt. The framework is based on Horn logical semantics-a logic programming encoding of formal semantics. A Horn logical semantics of the language Ls is constructed which employs the parse trees of the language Lt as semantic domains for expressing the meaning of sentences in Ls. This formal semantics, coded in logic programming, immediately yields an executable (reversible) filter. This (reversible) filter is provably correct, as it is generated from the semantic specification. Our approach provides a formal basis for interoperability and is illustrated through five major practical applications: Translating Nemeth Math Braille notation to LATEX, translating HTML to VoiceXML to make web-pages accessible via an audio-browser or a phone, translating ODBC programs/data to OQL (Object Query Language) programs/data, automatically generating validating parsers for XML, and interoperating between various biological software systems developed for phylogenetic inference via the NEXUS data representation language.

Relaxation on optimization predicates

Traditional constraint logic programming (CLP) specifies an optimization problem by using a set of constraints and an objective function. In many applications, optimal solutions may be difficult or impossible to obtain, and hence we are interested in finding suboptimal solutions, by either relaxing the constraints or the objective function. Hierarchical constraint logic programming (HCLP) [1] is such a strategy by extending CLP to support required as well as relaxable constraints. HCLP proposed preferences on constraints indicating the relative importance of constraints and organizing them into a hierarchy. Essentially, the solutions of interest must satisfy the required constraints but need not satisfy the relaxable constraints. HCLP has proven to be useful tool in solving the over-constrained applications.

Mode-directed fixed point computation

Goal-directed fixed point computation strategies have been widely adopted in the tabled logic programming paradigm. However, there are many situations in which a fixed point contains a large number or even infinite number of solutions. In these cases, a fixed point computation engine may not be efficient enough or feasible at all. We present a mode-declaration scheme which provides the capabilities to reduce a fixed point from a big solution set to a preferred small one, or from an infeasible infinite set to a finite one. We show the correctness of the mode-declaration scheme. One motivating application of our mode-declaration scheme is for dynamic programming, which is typically used for solving optimization problems. There is no need to define the value of an optimal solution recursively, instead, defining a general solution suffices. The optimal value as well as its corresponding concrete solution can be derived implicitly and automatically using a mode-directed fixed point computation engine. This mode-directed fixed point computation engine has been successfully implemented in a commercial Prolog system.