Exact Algorithms for Linear Programming over Algebraic Extensions

Abstract. We study the computational complexity of linear programs with coefficients that are real algebraic numbers under a Turing machine model of computation. After reviewing a method for exact representation of algebraic numbers under the Turing model, we show that the fundamental tasks of comparison and arithmetic can be performed in polynomial time. Our technique for establishing polynomial-time algorithms for comparison and arithmetic is distinct from the usual resultant-based approaches, and has the advantage that it provides a natural framework for analysis of the complexity of computational tasks, such as Gaussian elimination, that involve a sequence of arithmetic operations. Our main contribution is to show that a variant of the ellipsoid method can be used to solve linear programming in time polynomial in the encoding size of the problem coefficients and the degree of any algebraic extension that contains those coefficients.     

On a Java computer algebra system, its performance and applications

This paper considers Java as an implementation language for a starting part of a computer algebra library. It describes a design of basic arithmetic and multivariate polynomial interfaces and classes which are then employed in advanced parallel and distributed Groebner base algorithms and applications. The library is type-safe due to its design with Java’s generic type parameters and thread-safe using Java’s concurrent programming facilities. We report on the performance of the polynomial arithmetic and on applications built upon the core library.     

A programmable ternary CPU using hybrid CMOS/memristor circuits

Abstract

The carry propagation of arithmetic operations is one of the major shortcomings of common binary number encodings as the two’s complement. Signed-digit arithmetic allows the addition of two numbers without carry propagation and in asymptotically constant time in dependence of the word length, while at the same time requiring a digit representation with more than two states. With the advent of memristors, it has become possible to store multiple states within a single memory cell. This paper proposes an implementation of a general purpose CPU using signed-digit arithmetic by exploiting memristors in order to implement multi-value registers. The proposed model of the CPU is evaluated by the execution of various image processing algorithms. It is shown that a break-even point exists at which signed-digit algorithms outperform conventional binary arithmetic operations. Furthermore, simulation results prove that the memristor device lends itself to store signed-digit data efficiently.     

Soft Linear Set Theory

A formulation of naïve set theory is given in Lafont’s Soft Linear Logic, a logic with polynomial time cut-elimination. We demonstrate that the provably total functions of this set theory are precisely the PTIME functions. A novelty of this approach is the representation of the unary/binary natural numbers by two distinct sets (the safe naturals and the soft naturals).     

Twin-float arithmetic

We present a heuristically certified form of floating-point arithmetic and its implementation in CoCoALib. This arithmetic is intended to act as a fast alternative to exact rational arithmetic, and is developed from the idea of paired floats expounded by Traverso and Zanoni (2002). As prerequisites we need a source of (pseudo-)random numbers, and an underlying floating-point arithmetic system where the user can set the precision. Twin-float arithmetic can be used only where the input data are exact, or can be obtained at high enough precision. Our arithmetic includes a total cancellation heuristic for sums and differences, and so can be used in classical algebraic algorithms such as Buchberger’s algorithm. We also present a (new) algorithm for recovering an exact rational value from a twin-float, so in some cases an exact answer can be obtained from an approximate computation.     

Best case lower bounds for Heapsort

The performance of Heapsort algorithms on arbitrary input is examined. It is proved that ann logn?O(n) lower bound on the number of comparisons holds for a set of Heapsort algorithms, including Williams-Floyd's algorithm, Carlsson's bottom-up linear or binary insertion algorithm, and all up-down algorithms, on any input.     

Formal Verification of C Systems Code

Systems code is almost universally written in the C programming language or a variant. C has a very low level of type and memory abstraction and formal reasoning about C systems code requires a memory model that is able to capture the semantics of C pointers and types. At the same time, proof-based verification demands abstraction, in particular from the aliasing and frame problems. In this paper we present a study in the mechanisation of two proof abstractions for pointer program verification in the Isabelle/HOL theorem prover, based on a low-level memory model for C. The language’s type system presents challenges for the multiple independent typed heaps (Burstall-Bornat) and separation logic proof techniques. In addition to issues arising from explicit value size/alignment, padding, type-unsafe casts and pointer address arithmetic, structured types such as C’s arrays and structs are problematic due to the non-monotonic nature of pointer and lvalue validity in the presence of the unary &-operator. For example, type-safe updates through pointers to fields of a struct break the independence of updates across typed heaps or ∧^*-conjuncts. We provide models and rules that are able to cope with these language features and types, eschewing common over-simplifications and utilising expressive shallow embeddings in higher-order logic. Two case studies are provided that demonstrate the applicability of the mechanised models to real-world systems code; a working of the standard in-place list reversal example and an overview of the verification of the L4 microkernel’s memory allocator.     

Exact Algorithms for Linear Programming over Algebraic Extensions

Abstract. We study the computational complexity of linear programs with coefficients that are real algebraic numbers under a Turing machine model of computation. After reviewing a method for exact representation of algebraic numbers under the Turing model, we show that the fundamental tasks of comparison and arithmetic can be performed in polynomial time. Our technique for establishing polynomial-time algorithms for comparison and arithmetic is distinct from the usual resultant-based approaches, and has the advantage that it provides a natural framework for analysis of the complexity of computational tasks, such as Gaussian elimination, that involve a sequence of arithmetic operations. Our main contribution is to show that a variant of the ellipsoid method can be used to solve linear programming in time polynomial in the encoding size of the problem coefficients and the degree of any algebraic extension that contains those coefficients.     

Grammar directed gödel numberings

The usual methods for associating natural numbers to syntactical objects (Gödel's coding based on prime numbers, codings via pairing functions or by enumerations) are either very complex or produce very high numbers, due to the fact that the numbering is with gaps.

In this paper we propose a method for obtaining good Gödel numberings which is based on the grammatical structure of the language to be coded.

The arithmetization is directed by a top-down parsing algorithm and it works only for context-free unambiguous grammars. It is proved that the coding function such obtained is a bijection between language and natural numbers and its computational complexity is lower than that of the enumerative coding. As an example, Cantor's pairing function is derived. Finally, it is shown how to apply the algorithm for obtaining good Gödel numberings for languages associated to first-order theories.     

An approach to high-level language bindings to XML

Values of existing typed programming languages are increasingly generated and manipulated outside the language jurisdiction. Instead, they often occur as fragments of XML documents, where they are uniformly interpreted as labelled trees in spite of their domain-specific semantics. In particular, the values are divorced from the high-level type with which they are conveniently, safely, and efficiently manipulated within the language.We propose language-specific mechanisms which extract language values from arbitrary XML documents and inject them in the language. In particular, we provide a general framework for the formal interpretation of extraction mechanisms and then instantiate it to the definition of a mechanism for a sample language core L. We prove that such mechanism can be built by giving a sound and complete algorithm that implements it.The values, types, and type semantics of L are sufficiently general to show that extraction mechanisms can be defined for many existing typed languages, including object-oriented languages. In fact, extraction mechanisms for a large class of existing languages can be directly derived from L's. As a proof of this, we introduce the SNAQue prototype system, which transforms XML fragments into CORBA objects and exposes them across the ORB framework to any CORBA-compliant language.     

Formal proof of integer adders using all-prefix-sums operation

Addition of two binary numbers is a fundamental operation in electronic circuits.Several integer adder architectures have been proposed.Their formal properties are well known,but the proofs are either incomplete or difficult to find.In this paper,we present a formal proof for the correctness of prefix adders.Both sequential and parallel algorithms are formalized and proved.In contrast to previous proofs using higher order functions and rewriting systems,our work is based on first order recursive equations,which are familiar to the computer arithmetic community and are therefore understandable by people working on VLSI circuit design.This study sets up a basis for further work on formal proofs of computer arithmetic algorithms.     

Ordinal Arithmetic: Algorithms and Mechanization

Termination proofs are of critical importance for establishing the correct behavior of both transformational and reactive computing systems. A general setting for establishing termination proofs involves the use of the ordinal numbers, an extension of the natural numbers into the transfinite that were introduced by Cantor in the nineteenth century and are at the core of modern set theory. We present the first comprehensive treatment of ordinal arithmetic on compact ordinal notations and give efficient algorithms for various operations, including addition, subtraction, multiplication, and exponentiation. Using the ACL2 theorem proving system, we implemented our ordinal arithmetic algorithms, mechanically verified their correctness, and developed a library of theorems that can be used to significantly automate reasoning involving the ordinals. To enable users of the ACL2 system to fully utilize our work required that we modify ACL2, e.g., we replaced the underlying representation of the ordinals and added a large library of definitions and theorems. Our modifications are available starting with ACL2 version 2.8.     

A view of computability on term algebras

A framework of definitions for, and questions about, notions of computability, complexity, and logic for term algebras is built around known results in the literature and the current work. The term algebra for finite binary trees and various classes of programs for computing on them, a class similar to LISP being the most powerful, serve as a focus. Several interesting classes of programs less powerful than LISP are obtained by varying the functions and predicates available in the programming language. It is shown how they relate to one another and then some of their properties are explored. For example, there is a class powerful enough to compute all the partial recursive functions on the natural numbers that is neither sufficiently powerful to code the binary trees into the natural numbers nor to recognize any set that is both infinite and coinfinite. A simple logic sufficient to talk about trees and LISP-like computations is given and it is suggested that certain pebble games provide very reasonable measures of complexity of trees. It is also indicated how various particular results give further insight into such fundamental notions as Turing computable and recursively enumerable.     

A System of Relational Syllogistic Incorporating Full Boolean Reasoning

We present a system of relational syllogistic, based on classical propositional logic, having primitives of the following form: $$\begin{array}{ll}\mathbf{Some}\, a \,{\rm are} \,R-{\rm related}\, {\rm to}\, \mathbf{some} \,b;\\ \mathbf{Some}\, a \,{\rm are}\,R-{\rm related}\, {\rm to}\, \mathbf{all}\, b;\\ \mathbf{All}\, a\, {\rm are}\,R-{\rm related}\, {\rm to}\, \mathbf{some}\, b;\\ \mathbf{All}\, a\, {\rm are}\,R-{\rm related}\, {\rm to}\, \mathbf{all} \,b.\end{array}$$ Such primitives formalize sentences from natural language like ‘All students read some textbooks’. Here a, b denote arbitrary sets (of objects), and R denotes an arbitrary binary relation between objects. The language of the logic contains only variables denoting sets, determining the class of set terms, and variables denoting binary relations between objects, determining the class of relational terms. Both classes of terms are closed under the standard Boolean operations. The set of relational terms is also closed under taking the converse of a relation. The results of the paper are the completeness theorem with respect to the intended semantics and the computational complexity of the satisfiability problem.     

Motion mapping and mode decision for MPEG-2 to H.264/AVC transcoding

This paper describes novel transcoding techniques aimed for low-complexity MPEG-2 to H.264/AVC transcoding. An important application for this type of conversion is efficient storage of broadcast video in consumer devices. The architecture for such a system is presented, which includes novel motion mapping and mode decision algorithms. For the motion mapping, two algorithms are presented. Both efficiently map incoming MPEG-2 motion vectors to outgoing H.264/AVC motion vectors regardless of the block sizes that the motion vectors correspond to. In addition, the algorithm maps motion vectors to different reference pictures, which is useful for picture type conversion and prediction from multiple reference pictures. We also propose an efficient rate-distortion optimised macroblock coding mode decision algorithm, which first evaluates candidate modes based on a simple cost function so that a reduced set of candidate modes is formed, then based on this reduced set, we evaluate the more complex Lagrangian cost calculation to determine the coding mode. Extensive simulation results show that our proposed transcoder incorporating the proposed algorithms achieves very good rate-distortion performance with low complexity. Compared with the cascaded decoder-encoder solution, the coding efficiency is maintained while the complexity is significantly reduced.

结构化文本语言编译器的虚拟机指令设计与优化

针对自主开发 IEC61131结构化文本(ST)语言编译器的需求,设计了一套机器无关的虚拟机指令集,指令集按照数据传送、算术运算、逻辑运算、位操作、比较操作、流程控制、函数调用等类型划分,采用三地址码的四元式表示.基于该指令集,设计了结构化文本语言的 IF语句、FOR语句、CASE语句、EXIT语句的指令形成算法,编译器将结构化文本语言编译为二进制指令文件.针对FOR语句提出了"向上计数"、"向下计数"、"动态确定上下限"的3种翻译模式,针对CASE语句提出了基于短路求值和跳转表混合的翻译模式,可优化FOR语句、CASE语句的指令结构.对编译形成的二进制指令,采用常量折叠计算、代数简化、临时变量消除、引用点分析等手段,进一步优化指令.实验测试结果表明,优化后的指令在嵌入式工控装置中的解释执行时提升了效率.     

Programming with dual numbers and its applications in mechanisms design

Dual numbers are expressed in the form x+y where ². Dual metanumbers are defined in this paper as DualZero, DualInf and DualNaN. The extended dual plane and the extended finite dual plane are introduced to describe dual numbers and dual metanumbers. Handling of dual numbers in the C^H programming language is presented. The I/O, arithmetic and relational operations, and built-in mathematical functions are defined for both dual numbers and dual metanumbers. As a result of polymorphism, the syntaxes of dual arithmetic and relational operations, and built-in dual functions are the same as those for real and complex numbers in the C^H programming language. The valid lvalues related to dual numbers in C^H are defined. The computation of the motion screw for a rigid-body displacement is used as an example to illustrate the creation of user's dual functions. The efficacy of C^H programming with dual numbers is demonstrated by displacement analysis of an RCCC mechanism. For the first time, dual data is handled as a built-in data type in a general-purpose computer programming language. Programming with dual numbers in C^H is simpler than in any other computer programming language.     

Formal methods applied to a floating-point number system

A formalization of the IEEE standard for binary floating-point arithmetic (ANSI/IEEE Std. 754-1985) is presented in the set-theoretic specification language Z. The formal specification is refined into four sequential components, which unpack the operands, perform the arithmetic, and pack and round the result. This refinement follows proven rules and so demonstrates a mathematically rigorous method of program development. In the course of the proofs, useful internal representations of floating-point numbers are specified. The procedures presented form the basis for the floating-point unit of the Inmos IMS T800 transputer     

Schröder-like algorithms for multiple complex zeros of a polynomial

Using the iterative method of Newton's type in circular arithmetic, introduced in [14], a new iterative method for finding a multiple complex zero of a polynomial is derived. This method can be regarded as a version of classical Schröder's method. Initial conditions which guarantee a safe convergence of the proposed method are stated. The increase of the computational efficiency is achieved by a combination of the complex approximation methods of Schröder's type with some interval methods. The presented algorithms are analysed in view of their efficiency and illustrated numerically in the example of a polynomial equation.     

Formula manipulation in ALGOL 68 and application to Routh's algorithm

This paper presents an implementation of Routh's algorithm and the Schur criterion, in order to determine the location of the zeros of a complex polynomial in one variable, over the ring of multivariate polynomials with integral coefficients. Both algorithms are applied to the characteristic polynomials of multistep methods. Moreover, procedures are given for the arithmetic operations +,?,*,÷ with arbitrarily long integral numbers as operands.