Interacting via the Heap in the Presence of Recursion

Almost all modern imperative programming languages include operations for dynamically manipulating the heap, for example by allocating and deallocating objects, and by updating reference fields. In the presence of recursive procedures and local variables the interactions of a program with the heap can become rather complex, as an unbounded number of objects can be allocated either on the call stack using local variables, or, anonymously, on the heap using reference fields. As such a static analysis is, in general, undecidable. In this paper we study the verification of recursive programs with unbounded allocation of objects, in a simple imperative language for heap manipulation. We present an improved semantics for this language, using an abstraction that is precise. For any program with a bounded visible heap, meaning that the number of objects reachable from variables at any point of execution is bounded, this abstraction is a finitary representation of its behaviour, even though an unbounded number of objects can appear in the state. As a consequence, for such programs model checking is decidable. Finally we introduce a specification language for temporal properties of the heap, and discuss model checking these properties against heap-manipulating programs.Comment: In Proceedings ICE 2012, arXiv:1212.345

Q-systems, Heaps, Paths and Cluster Positivity

We consider the cluster algebra associated to the $Q$-system for $A_r$ as a tool for relating $Q$-system solutions to all possible sets of initial data. We show that the conserved quantities of the $Q$-system are partition functions for hard particles on particular target graphs with weights, which are determined by the choice of initial data. This allows us to interpret the simplest solutions of the Q-system as generating functions for Viennot's heaps on these target graphs, and equivalently as generating functions of weighted paths on suitable dual target graphs. The generating functions take the form of finite continued fractions. In this setting, the cluster mutations correspond to local rearrangements of the fractions which leave their final value unchanged. Finally, the general solutions of the $Q$-system are interpreted as partition functions for strongly non-intersecting families of lattice paths on target lattices. This expresses all cluster variables as manifestly positive Laurent polynomials of any initial data, thus proving the cluster positivity conjecture for the $A_r$ $Q$-system. We also give an alternative formulation in terms of domino tilings of deformed Aztec diamonds with defects.Comment: 106 pages, 38 figure

The Coulomb impurity problem in graphene

We address the problem of an unscreened Coulomb charge in graphene, and calculate the local density of states and displaced charge as a function of energy and distance from the impurity. This is done non-perturbatively in two different ways: (1) solving the problem exactly by studying numerically the tight-binding model on the lattice; (2) using the continuum description in terms of the 2D Dirac equation. We show that the Dirac equation, when properly regularized, provides a qualitative and quantitative low energy description of the problem. The lattice solution shows extra features that cannot be described by the Dirac equation, namely bound state formation and strong renormalization of the van Hove singularities.Comment: 3 Figures; minor typo corrections and minor update in Fig. 3

Session Types in Concurrent Calculi: Higher-Order Processes and Objects

This dissertation investigates different formalisms, in the form of programming language calculi, that are aimed at providing a theoretical foundation for structured concurrent programming based on session types. The structure of a session type is essentially a process-algebraic style description of the behaviour of a single program identifier serving as a communication medium (and usually referred to as a channel): the types incorporate typed inputs, outputs, and choices which can be composed to form larger protocol descriptions. The effectiveness of session typing can be attributed to the linear treatment of channels and session types, and to the use of tractable methods such as syntactic duality to decide if the types of two connected channels are compatible. Linearity is ensured when accumulating the uses of a channel into a composite type that describes also the order of those actions. Duality provides a tractable and intuitive method for deciding when two connected channels can interact and exchange values in a statically determined type-safe way. We present our contributions to the theory of sessions, distilled into two families of programming calculi, the first based on higher-order processes and the second based on objects. Our work unifies, improves and extends, in manifold ways, the session primitives and typing systems for the Lambda-calculus, the Pi-calculus, the Object-calculus, and their combinations in multi-paradigm languages. Of particular interest are: the treatment of infinite interactions expressed with recursive sessions; the capacity to encapsulate channels in higher-order structures which can be exchanged and kept suspended, i.e., the use of code as data; the integration of protocol structure directly into the description of objects, providing a powerful and uniformly extensible set of implementation abstractions; finally, the introduction of asynchronous subtyping, which enables controlled reordering of actions on either side of a session. Our work on higher-order processes and on object calculi for session-based concurrent programming provides a theoretical foundation for programming language design integrating functional, process, and object-oriented features

Functional Closure of Schwinger-Dyson Equations in Quantum Electrodynamics, Part 1: Generation of Connected and One-Particle Irreducible Feynman Diagrams

Using functional derivatives with respect to free propagators and interactions we derive a closed set of Schwinger-Dyson equations in quantum electrodynamics. Its conversion to graphical recursion relations allows us to systematically generate all connected and one-particle irreducible Feynman diagrams for the $n$-point functions and the vacuum energy together with their correct weights.Comment: Author Information under http://www.physik.fu-berlin.de/~kleinert/institution.html Latest update of paper also at http://www.physik.fu-berlin.de/~kleinert/32

Dynamics of One-dimensional Self-gravitating Systems Using Hermite-Legendre Polynomials

The current paradigm for understanding galaxy formation in the universe depends on the existence of self-gravitating collisionless dark matter. Modeling such dark matter systems has been a major focus of astrophysicists, with much of that effort directed at computational techniques. Not surprisingly, a comprehensive understanding of the evolution of these self-gravitating systems still eludes us, since it involves the collective nonlinear dynamics of many-particle systems interacting via long-range forces described by the Vlasov equation. As a step towards developing a clearer picture of collisionless self-gravitating relaxation, we analyze the linearized dynamics of isolated one-dimensional systems near thermal equilibrium by expanding their phase space distribution functions f(x,v) in terms of Hermite functions in the velocity variable, and Legendre functions involving the position variable. This approach produces a picture of phase-space evolution in terms of expansion coefficients, rather than spatial and velocity variables. We obtain equations of motion for the expansion coefficients for both test-particle distributions and self-gravitating linear perturbations of thermal equilibrium. N-body simulations of perturbed equilibria are performed and found to be in excellent agreement with the expansion coefficient approach over a time duration that depends on the size of the expansion series used.Comment: 12 pages, accepted for publication in MNRA

Programming Language Abstractions for Modularly Verified Distributed Systems

Distributed systems are rarely developed as monolithic programs. Instead, like any software, these systems may consist of multiple program components, which are then compiled separately and linked together. Modern systems also incorporate various services interacting with each other and with client applications. However, state-of-the-art verification tools focus predominantly on verifying standalone, closed-world protocols or systems, thus failing to account for the compositional nature of distributed systems. For example, standalone verification has the drawback that when protocols and their optimized implementations evolve, one must re-verify the entire system from scratch, instead of leveraging compositionality to contain the reverification effort. In this paper, we focus on the challenge of modular verification of distributed systems with respect to high-level protocol invariants as well as for low-level implementation safety properties. We argue that the missing link between the two is a programming paradigm that would allow one to reason about both high-level distributed protocols and low-level implementation primitives in a single verification-friendly framework. Such a link would make it possible to reap the benefits from both the vast body of research in distributed computing, focused on modular protocol decomposition and consistency properties, as well as from the recent advances in program verification, enabling construction of provably correct systems implementations. To showcase the modular verification challenges, we present some typical scenarios of decomposition between a distributed protocol and its implementations. We then describe our ongoing research agenda, in which we are attempting to address the outlined problems by providing a typing discipline and a set of domain-specific primitives for specifying, implementing and verifying distributed systems. Our approach, mechanized within a proof assistant, provides the means of decomposition necessary for modular proofs about distributed protocols and systems

Program verification with interacting analysis plugins

In this paper we propose and argue for a modular framework for interprocedural program analysis, where multiple program analysis tools are combined in order to exploit the particular advantages of each. This allows for “plugging together” such tools as required by each verification task and makes it easy to integrate new analyses. Our framework automates the sharing of information between plugins using a first order logic with transitive closure, in a way inspired by the open product of Cortesi et al.. We describe a prototype implementation of our framework, which performs static assertion checking on a simple language for heap-manipulating programs. This implementation includes plugins for three existing approaches — predicate abstraction, 3-valued shape analysis and a decidable pointer analysis — and for a simple type system. We demonstrate through a detailed example the increase in precision that our approach can provide. Finally we discuss the design decisions we have taken, in particular the tradeoffs involved in the choice of language by which the plugins communicate, and identify some future directions for our work

PLACES'10: The 3rd Workshop on Programmng Language Approaches to concurrency and Communication-Centric Software

Paphos, Cyprus. March 201