Locality refinement

We study re nement in the setting of local reasoning. In particular, we explore general translations that preserve and that break locality

Specifying and Verifying Concurrent Algorithms with Histories and Subjectivity

We present a lightweight approach to Hoare-style specifications for fine-grained concurrency, based on a notion of time-stamped histories that abstractly capture atomic changes in the program state. Our key observation is that histories form a partial commutative monoid, a structure fundamental for representation of concurrent resources. This insight provides us with a unifying mechanism that allows us to treat histories just like heaps in separation logic. For example, both are subject to the same assertion logic and inference rules (e.g., the frame rule). Moreover, the notion of ownership transfer, which usually applies to heaps, has an equivalent in histories. It can be used to formally represent helping---an important design pattern for concurrent algorithms whereby one thread can execute code on behalf of another. Specifications in terms of histories naturally abstract granularity, in the sense that sophisticated fine-grained algorithms can be given the same specifications as their simplified coarse-grained counterparts, making them equally convenient for client-side reasoning. We illustrate our approach on a number of examples and validate all of them in Coq.Comment: 17 page

Modular termination verification for non-blocking concurrency

© Springer-Verlag Berlin Heidelberg 2016.We present Total-TaDA, a program logic for verifying the total correctness of concurrent programs: that such programs both terminate and produce the correct result. With Total-TaDA, we can specify constraints on a thread’s concurrent environment that are necessary to guarantee termination. This allows us to verify total correctness for nonblocking algorithms, e.g. a counter and a stack. Our specifications can express lock- and wait-freedom. More generally, they can express that one operation cannot impede the progress of another, a new non-blocking property we call non-impedance. Moreover, our approach is modular. We can verify the operations of a module independently, and build up modules on top of each other

Color-dressed recursive relations for multi-parton amplitudes

Remarkable progress inspired by twistors has lead to very simple analytic expressions and to new recursive relations for multi-parton color-ordered amplitudes. We show how such relations can be extended to include color and present the corresponding color-dressed formulation for the Berends-Giele, BCF and a new kind of CSW recursive relations. A detailed comparison of the numerical efficiency of the different approaches to the calculation of multi-parton cross sections is performed.Comment: 31 pages, 4 figures, 6 table

First-principles study of ternary fcc solution phases from special quasirandom structures

In the present work, ternary Special Quasirandom Structures (SQSs) for a fcc solid solution phase are generated at different compositions, $x_A=x_B=x_C=\tfrac{1}{3}$ and $x_A=\tfrac{1}{2}$, $x_B=x_C=\tfrac{1}{4}$, whose correlation functions are satisfactorily close to those of a random fcc solution. The generated SQSs are used to calculate the mixing enthalpy of the fcc phase in the Ca-Sr-Yb system. It is observed that first-principles calculations of all the binary and ternary SQSs in the Ca-Sr-Yb system exhibit very small local relaxation. It is concluded that the fcc ternary SQSs can provide valuable information about the mixing behavior of the fcc ternary solid solution phase. The SQSs presented in this work can be widely used to study the behavior of ternary fcc solid solutions.Comment: 20 pages, 7 figure

History-based verification of functional behaviour of concurrent programs

Modular verification of the functional behaviour of a concurrent program remains a challenge. We propose a new way to achieve this, using histories, modelled as process algebra terms, to keep track of local changes. When threads terminate or synchronise in some other way, local histories are combined into global histories, and by resolving the global histories, the reachable state properties can be determined. Our logic is an extension of permission-based separation logic, which supports expressive and intuitive specifications. We discuss soundness of the approach, and illustrate it on several examples

Ordering variable for parton showers

The parton splittings in a parton shower are ordered according to an ordering variable, for example the transverse momentum of the daughter partons relative to the direction of the mother, the virtuality of the splitting, or the angle between the daughter partons. We analyze the choice of the ordering variable and conclude that one particular choice has the advantage of factoring softer splittings from harder splittings graph by graph in a physical gauge.Comment: 28 pages, 5 figure

Coherent Parton Showers with Local Recoils

We outline a new formalism for dipole-type parton showers which maintain exact energy-momentum conservation at each step of the evolution. Particular emphasis is put on the coherence properties, the level at which recoil effects do enter and the role of transverse momentum generation from initial state radiation. The formulated algorithm is shown to correctly incorporate coherence for soft gluon radiation. Furthermore, it is well suited for easing matching to next-to-leading order calculations.Comment: 24 pages, 3 figure

Modular termination veri cation for non-blocking concurrency (extended version)

We present Total-TaDA, a program logic for verifying the total correctness of concurrent programs: that such programs both terminate and produce the correct result. With Total-TaDA, we can specify constraints on a thread's concurrent environment that are necessary to guarantee termination. This allows us to verify total correctness for nonblocking algorithms, e.g. a counter and a stack. Our speci cations can express lock- and wait-freedom. More generally, they can express that one operation cannot impede the progress of another, a new non-blocking property we call non-impedance. Moreover, our approach is modular. We can verify the operations of a module independently, and build up modules on top of each other