1,995 research outputs found
Solving Degenerate Sparse Polynomial Systems Faster
Consider a system F of n polynomial equations in n unknowns, over an
algebraically closed field of arbitrary characteristic. We present a fast
method to find a point in every irreducible component of the zero set Z of F.
Our techniques allow us to sharpen and lower prior complexity bounds for this
problem by fully taking into account the monomial term structure. As a
corollary of our development we also obtain new explicit formulae for the exact
number of isolated roots of F and the intersection multiplicity of the
positive-dimensional part of Z. Finally, we present a combinatorial
construction of non-degenerate polynomial systems, with specified monomial term
structure and maximally many isolated roots, which may be of independent
interest.Comment: This is the final journal version of math.AG/9702222 (``Toric
Generalized Characteristic Polynomials''). This final version is a major
revision with several new theorems, examples, and references. The prior
results are also significantly improve
On Characterizing the Data Access Complexity of Programs
Technology trends will cause data movement to account for the majority of
energy expenditure and execution time on emerging computers. Therefore,
computational complexity will no longer be a sufficient metric for comparing
algorithms, and a fundamental characterization of data access complexity will
be increasingly important. The problem of developing lower bounds for data
access complexity has been modeled using the formalism of Hong & Kung's
red/blue pebble game for computational directed acyclic graphs (CDAGs).
However, previously developed approaches to lower bounds analysis for the
red/blue pebble game are very limited in effectiveness when applied to CDAGs of
real programs, with computations comprised of multiple sub-computations with
differing DAG structure. We address this problem by developing an approach for
effectively composing lower bounds based on graph decomposition. We also
develop a static analysis algorithm to derive the asymptotic data-access lower
bounds of programs, as a function of the problem size and cache size
Liveness-Driven Random Program Generation
Randomly generated programs are popular for testing compilers and program
analysis tools, with hundreds of bugs in real-world C compilers found by random
testing. However, existing random program generators may generate large amounts
of dead code (computations whose result is never used). This leaves relatively
little code to exercise a target compiler's more complex optimizations.
To address this shortcoming, we introduce liveness-driven random program
generation. In this approach the random program is constructed bottom-up,
guided by a simultaneous structural data-flow analysis to ensure that the
generator never generates dead code.
The algorithm is implemented as a plugin for the Frama-C framework. We
evaluate it in comparison to Csmith, the standard random C program generator.
Our tool generates programs that compile to more machine code with a more
complex instruction mix.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
FO-definable transformations of infinite strings
The theory of regular and aperiodic transformations of finite strings has
recently received a lot of interest. These classes can be equivalently defined
using logic (Monadic second-order logic and first-order logic), two-way
machines (regular two-way and aperiodic two-way transducers), and one-way
register machines (regular streaming string and aperiodic streaming string
transducers). These classes are known to be closed under operations such as
sequential composition and regular (star-free) choice; and problems such as
functional equivalence and type checking, are decidable for these classes. On
the other hand, for infinite strings these results are only known for
-regular transformations: Alur, Filiot, and Trivedi studied
transformations of infinite strings and introduced an extension of streaming
string transducers over -strings and showed that they capture monadic
second-order definable transformations for infinite strings. In this paper we
extend their work to recover connection for infinite strings among first-order
logic definable transformations, aperiodic two-way transducers, and aperiodic
streaming string transducers
Efficient Monitoring of ??-languages
We present a technique for generating efficient monitors for Omega-regular-languages. We show how Buchi automata can be reduced in size and transformed into special, statistically optimal nondeterministic finite state machines, called binary transition tree finite state machines (BTT-FSMs), which recognize precisely the minimal bad prefixes of the original omega-regular-language. The presented technique is implemented as part of a larger monitoring framework and is available for download
Specifying and Executing Optimizations for Parallel Programs
Compiler optimizations, usually expressed as rewrites on program graphs, are
a core part of all modern compilers. However, even production compilers have
bugs, and these bugs are difficult to detect and resolve. The problem only
becomes more complex when compiling parallel programs; from the choice of graph
representation to the possibility of race conditions, optimization designers
have a range of factors to consider that do not appear when dealing with
single-threaded programs. In this paper we present PTRANS, a domain-specific
language for formal specification of compiler transformations, and describe its
executable semantics. The fundamental approach of PTRANS is to describe program
transformations as rewrites on control flow graphs with temporal logic side
conditions. The syntax of PTRANS allows cleaner, more comprehensible
specification of program optimizations; its executable semantics allows these
specifications to act as prototypes for the optimizations themselves, so that
candidate optimizations can be tested and refined before going on to include
them in a compiler. We demonstrate the use of PTRANS to state, test, and refine
the specification of a redundant store elimination optimization on parallel
programs.Comment: In Proceedings GRAPHITE 2014, arXiv:1407.767
Hilbert's Program Then and Now
Hilbert's program was an ambitious and wide-ranging project in the philosophy
and foundations of mathematics. In order to "dispose of the foundational
questions in mathematics once and for all, "Hilbert proposed a two-pronged
approach in 1921: first, classical mathematics should be formalized in
axiomatic systems; second, using only restricted, "finitary" means, one should
give proofs of the consistency of these axiomatic systems. Although Godel's
incompleteness theorems show that the program as originally conceived cannot be
carried out, it had many partial successes, and generated important advances in
logical theory and meta-theory, both at the time and since. The article
discusses the historical background and development of Hilbert's program, its
philosophical underpinnings and consequences, and its subsequent development
and influences since the 1930s.Comment: 43 page
- âŚ