Alloy*: a general-purpose higher-order relational constraint solver

@article{Milicevic2019AlloyAG,
  title={Alloy*: a general-purpose higher-order relational constraint solver},
  author={Aleksandar Milicevic and Joseph P. Near and Eunsuk Kang and Daniel Jackson},
  journal={Formal Methods in System Design},
  year={2019},
  pages={1-32}
}
The last decade has seen a dramatic growth in the use of constraint solvers as a computational mechanism, not only for analysis of software, but also at runtime. Solvers are available for a variety of logics but are generally restricted to first-order formulas. Some tasks, however, most notably those involving synthesis, are inherently higher order; these are typically handled by embedding a first-order solver (such as a SAT or SMT solver) in a domain-specific algorithm. Using strategies… 
PrideMM: Second Order Model Checking for Memory Consistency Models
TLDR
It is argued that second-order logic sits at a sweet spot: constrained enough to enable practical solving, yet expressive enough to cover an important class of problems not amenable to (non-quantified) satisfiability solvers.
Bordeaux: A Tool for Thinking Outside the Box
TLDR
A prototype extension of the Alloy Analyzer is developed, named Bordeaux, that can find examples that are near the border of what is permitted, and hence might be desirable and help the user understand underconstraint bugs in the model.
Synthesizing memory models from framework sketches and Litmus tests
TLDR
It is shown that MemSynth can synthesize specifications for x86 in under two seconds, and for PowerPC in 12 seconds from 768 litmus tests, and it is used to reproduce, debug, and automatically repair a paper on comparing memory models in just two days.
Automated Model Repair for Alloy
TLDR
The first technique for repairing declarative models in Alloy - a first order relational logic with transitive closure is introduced, ARepair, which integrates ideas from mutation testing and program synthesis to provide an effective solution for repairing Alloy models.
Automated Test Generation and Mutation Testing for Alloy
We present two novel approaches for automated testing of models written in Alloy – a well-known declarative, first-order language that is supported by a fully automatic SAT-based analysis engine. The
The Pragmatic Dimension of Formal Methods: Towards Building a Sound Synthesiser
TLDR
Two representative strategies for achieving correct code from formal specifications are found: one is based on proposing refinements until a certain concrete design is achieved and then an almost direct mapping from mathematical elements to the source code of some programming language is made.
The effect of distance metrics in a general purpose synthesizer: An empirical study on integer domain imperative programs
TLDR
A program synthesizer that integrates genetic algorithm with model finder and argues that different distance metrics for a fitness function may reveal behavioral differences in the genetic algorithm is developed.
How Formal Methods Can Contribute to 5G Networks
TLDR
This chapter introduces some of the novel application areas for Software Defined Networks (SDN) and Network Function Virtualization (NFV), and proposes automated methods to create formal models that satisfy a given set of requirements for SDN and NFV.
Modelling and Reasoning with Software Product Lines with Design Choices
TLDR
sig Choice {} sig Mutex, IncrementalHeat extends Choice {} where mutex is a type of choice and heat is a parameter of choice.
Special Issue on Syntax-Guided Synthesis Preface
...
1
2
...

References

SHOWING 1-10 OF 56 REFERENCES
Alloy*: A Higher-Order Relational Constraint Solver
TLDR
This work shows how to extend a first-order solver (in this case Kodkod, a model finder for relational logic used as the engine of the Alloy Analyzer) so that it can handle quantifications over higher-order structures, and shows how this approach may bring similar benefits to a new class of tools.
Checking Properties of Heap-Manipulating Procedures with a Constraint Solver
TLDR
This paper shows how a suite of optimizations based on a special treatment of relations that are known to be functional, and target all steps results in much improved scalability.
A constraint solver for software engineering: finding models and cores of large relational specifications
TLDR
This thesis presents an efficient constraint solver for relational logic, with recent applications to design analysis, code checking, test-case generation, and declarative configuration, and new techniques for expanding the capacity and applicability of SAT-based engines.
Growing solver-aided languages with rosette
TLDR
ROSETTE is introduced, a framework for designing solver-aided languages that frees designers from having to compile their languages to constraints and describes three case studies of using ROSETTE to implement languages and synthesizers for web scraping, spatial programming, and superoptimization of bitvector programs.
Model Finding for Recursive Functions in SMT
TLDR
A translation that reduces axioms specifying a large class of recursive functions, including terminating functions, to universally quantified formulas for which these techniques are applicable is introduced.
Efficient E-Matching for SMT Solvers
TLDR
An index that works on E-graphs is introduced, called E-matching code treesthat combine features of substitution and code trees, used in saturation based theorem provers and shows substantial performance improvements over existing state-of-the-art SMT solvers.
Program Verification as Satisfiability Modulo Theories
TLDR
This paper makes a case that SMT-LIB can be used, and to a limited extent adapted, for exchanging symbolic software model checking benchmarks, and argues that it can be adapted to be a standard interchange medium for software modelchecking and related problems.
Constraints as control
TLDR
This work presents an extension of Scala that supports constraint programming over bounded and unbounded domains, and finds Kaplan promising because it is expressive, supporting a range of problem domains, while enabling full-speed execution of programs that do not rely on constraint programming.
Path-based inductive synthesis for program inversion
TLDR
The problem of semi-automated inversion of imperative programs, which has the potential to make it much easier and less error prone to write programs that naturally pair as inverses, is investigated and a novel synthesis technique called Path-based inductive synthesis (PINS) is proposed.
Unifying execution of imperative and declarative code
TLDR
This work presents a unified environment for running declarative specifications in the context of an imperative object-Oriented programming language, and presents an optimization technique that allowed them to run their tool on heaps with almost 2000 objects.
...
1
2
3
4
5
...