78,685 research outputs found
Synthesis of Parametric Programs using Genetic Programming and Model Checking
Formal methods apply algorithms based on mathematical principles to enhance
the reliability of systems. It would only be natural to try to progress from
verification, model checking or testing a system against its formal
specification into constructing it automatically. Classical algorithmic
synthesis theory provides interesting algorithms but also alarming high
complexity and undecidability results. The use of genetic programming, in
combination with model checking and testing, provides a powerful heuristic to
synthesize programs. The method is not completely automatic, as it is fine
tuned by a user that sets up the specification and parameters. It also does not
guarantee to always succeed and converge towards a solution that satisfies all
the required properties. However, we applied it successfully on quite
nontrivial examples and managed to find solutions to hard programming
challenges, as well as to improve and to correct code. We describe here several
versions of our method for synthesizing sequential and concurrent systems.Comment: In Proceedings INFINITY 2013, arXiv:1402.661
System Level Synthesis via Dynamic Programming
System Level Synthesis (SLS) parametrization facilitates controller synthesis
for large, complex, and distributed systems by incorporating system level
constraints (SLCs) into a convex SLS problem and mapping its solution to stable
controller design. Solving the SLS problem at scale efficiently is challenging,
and current attempts take advantage of special system or controller structures
to speed up the computation in parallel. However, those methods do not
generalize as they rely on the specific system/controller properties.
We argue that it is possible to solve general SLS problems more efficiently
by exploiting the structure of SLS constraints. In particular, we derive
dynamic programming (DP) algorithms to solve SLS problems. In addition to the
plain SLS without any SLCs, we extend DP to tackle infinite horizon SLS
approximation and entrywise linear constraints, which form a superclass of the
locality constraints. Comparing to convex program solver and naive analytical
derivation, DP solves SLS 4 to 12 times faster and scales with little
computation overhead. We also quantize the cost of synthesizing a controller
that stabilizes the system in a finite horizon through simulations
Applying Formal Methods to Networking: Theory, Techniques and Applications
Despite its great importance, modern network infrastructure is remarkable for
the lack of rigor in its engineering. The Internet which began as a research
experiment was never designed to handle the users and applications it hosts
today. The lack of formalization of the Internet architecture meant limited
abstractions and modularity, especially for the control and management planes,
thus requiring for every new need a new protocol built from scratch. This led
to an unwieldy ossified Internet architecture resistant to any attempts at
formal verification, and an Internet culture where expediency and pragmatism
are favored over formal correctness. Fortunately, recent work in the space of
clean slate Internet design---especially, the software defined networking (SDN)
paradigm---offers the Internet community another chance to develop the right
kind of architecture and abstractions. This has also led to a great resurgence
in interest of applying formal methods to specification, verification, and
synthesis of networking protocols and applications. In this paper, we present a
self-contained tutorial of the formidable amount of work that has been done in
formal methods, and present a survey of its applications to networking.Comment: 30 pages, submitted to IEEE Communications Surveys and Tutorial
Optimization of Occlusion-Inducing Depth Pixels in 3-D Video Coding
The optimization of occlusion-inducing depth pixels in depth map coding has
received little attention in the literature, since their associated texture
pixels are occluded in the synthesized view and their effect on the synthesized
view is considered negligible. However, the occlusion-inducing depth pixels
still need to consume the bits to be transmitted, and will induce geometry
distortion that inherently exists in the synthesized view. In this paper, we
propose an efficient depth map coding scheme specifically for the
occlusion-inducing depth pixels by using allowable depth distortions. Firstly,
we formulate a problem of minimizing the overall geometry distortion in the
occlusion subject to the bit rate constraint, for which the depth distortion is
properly adjusted within the set of allowable depth distortions that introduce
the same disparity error as the initial depth distortion. Then, we propose a
dynamic programming solution to find the optimal depth distortion vector for
the occlusion. The proposed algorithm can improve the coding efficiency without
alteration of the occlusion order. Simulation results confirm the performance
improvement compared to other existing algorithms
An Efficient Policy Iteration Algorithm for Dynamic Programming Equations
We present an accelerated algorithm for the solution of static
Hamilton-Jacobi-Bellman equations related to optimal control problems. Our
scheme is based on a classic policy iteration procedure, which is known to have
superlinear convergence in many relevant cases provided the initial guess is
sufficiently close to the solution. In many cases, this limitation degenerates
into a behavior similar to a value iteration method, with an increased
computation time. The new scheme circumvents this problem by combining the
advantages of both algorithms with an efficient coupling. The method starts
with a value iteration phase and then switches to a policy iteration procedure
when a certain error threshold is reached. A delicate point is to determine
this threshold in order to avoid cumbersome computation with the value
iteration and, at the same time, to be reasonably sure that the policy
iteration method will finally converge to the optimal solution. We analyze the
methods and efficient coupling in a number of examples in dimension two, three
and four illustrating its properties
Programming Not Only by Example
In recent years, there has been tremendous progress in automated synthesis
techniques that are able to automatically generate code based on some intent
expressed by the programmer. A major challenge for the adoption of synthesis
remains in having the programmer communicate their intent. When the expressed
intent is coarse-grained (for example, restriction on the expected type of an
expression), the synthesizer often produces a long list of results for the
programmer to choose from, shifting the heavy-lifting to the user. An
alternative approach, successfully used in end-user synthesis is programming by
example (PBE), where the user leverages examples to interactively and
iteratively refine the intent. However, using only examples is not expressive
enough for programmers, who can observe the generated program and refine the
intent by directly relating to parts of the generated program.
We present a novel approach to interacting with a synthesizer using a
granular interaction model. Our approach employs a rich interaction model where
(i) the synthesizer decorates a candidate program with debug information that
assists in understanding the program and identifying good or bad parts, and
(ii) the user is allowed to provide feedback not only on the expected output of
a program, but also on the underlying program itself. That is, when the user
identifies a program as (partially) correct or incorrect, they can also
explicitly indicate the good or bad parts, to allow the synthesizer to accept
or discard parts of the program instead of discarding the program as a whole.
We show the value of our approach in a controlled user study. Our study shows
that participants have strong preference to using granular feedback instead of
examples, and are able to provide granular feedback much faster
- …