51,846 research outputs found
Initial Algebra Semantics for Cyclic Sharing Tree Structures
Terms are a concise representation of tree structures. Since they can be
naturally defined by an inductive type, they offer data structures in
functional programming and mechanised reasoning with useful principles such as
structural induction and structural recursion. However, for graphs or
"tree-like" structures - trees involving cycles and sharing - it remains
unclear what kind of inductive structures exists and how we can faithfully
assign a term representation of them. In this paper we propose a simple term
syntax for cyclic sharing structures that admits structural induction and
recursion principles. We show that the obtained syntax is directly usable in
the functional language Haskell and the proof assistant Agda, as well as
ordinary data structures such as lists and trees. To achieve this goal, we use
a categorical approach to initial algebra semantics in a presheaf category.
That approach follows the line of Fiore, Plotkin and Turi's models of abstract
syntax with variable binding
On Automated Lemma Generation for Separation Logic with Inductive Definitions
Separation Logic with inductive definitions is a well-known approach for
deductive verification of programs that manipulate dynamic data structures.
Deciding verification conditions in this context is usually based on
user-provided lemmas relating the inductive definitions. We propose a novel
approach for generating these lemmas automatically which is based on simple
syntactic criteria and deterministic strategies for applying them. Our approach
focuses on iterative programs, although it can be applied to recursive programs
as well, and specifications that describe not only the shape of the data
structures, but also their content or their size. Empirically, we find that our
approach is powerful enough to deal with sophisticated benchmarks, e.g.,
iterative procedures for searching, inserting, or deleting elements in sorted
lists, binary search tress, red-black trees, and AVL trees, in a very efficient
way
Automorphism Groups of Geometrically Represented Graphs
We describe a technique to determine the automorphism group of a
geometrically represented graph, by understanding the structure of the induced
action on all geometric representations. Using this, we characterize
automorphism groups of interval, permutation and circle graphs. We combine
techniques from group theory (products, homomorphisms, actions) with data
structures from computer science (PQ-trees, split trees, modular trees) that
encode all geometric representations.
We prove that interval graphs have the same automorphism groups as trees, and
for a given interval graph, we construct a tree with the same automorphism
group which answers a question of Hanlon [Trans. Amer. Math. Soc 272(2), 1982].
For permutation and circle graphs, we give an inductive characterization by
semidirect and wreath products. We also prove that every abstract group can be
realized by the automorphism group of a comparability graph/poset of the
dimension at most four
Inductive benchmarking for purely functional data structures
Every designer of a new data structure wants to know how well it performs in comparison with others. But finding, coding and testing applications as benchmarks can be tedious and time-consuming. Besides, how a benchmark uses a data structure may considerably affect its apparent efficiency, so the choice of applications may bias the results. We address these problems by developing a tool for inductive benchmarking. This tool, Auburn, can generate benchmarks across a wide distribution of uses. We precisely define 'the use of a data structure', upon which we build the core algorithms of Auburn: how to generate a benchmark from a description of use, and how to extract a description of use from an application. We then apply inductive classification techniques to obtain decision trees for the choice between competing data structures. We test Auburn by benchmarking several implementations of three common data structures: queues, random-access lists and heaps. These and other results show Auburn to be a useful and accurate tool, but they also reveal some limitations of the approach
Deciding Entailments in Inductive Separation Logic with Tree Automata
Separation Logic (SL) with inductive definitions is a natural formalism for
specifying complex recursive data structures, used in compositional
verification of programs manipulating such structures. The key ingredient of
any automated verification procedure based on SL is the decidability of the
entailment problem. In this work, we reduce the entailment problem for a
non-trivial subset of SL describing trees (and beyond) to the language
inclusion of tree automata (TA). Our reduction provides tight complexity bounds
for the problem and shows that entailment in our fragment is EXPTIME-complete.
For practical purposes, we leverage from recent advances in automata theory,
such as inclusion checking for non-deterministic TA avoiding explicit
determinization. We implemented our method and present promising preliminary
experimental results
Fibrational induction rules for initial algebras
This paper provides an induction rule that can be used to prove properties of data structures whose types are inductive, i.e., are carriers of initial algebras of functors. Our results are semantic in nature and are inspired by Hermida and Jacobs’ elegant algebraic formulation of induction for polynomial data types. Our contribution is to derive, under slightly different assumptions, an induction rule that is generic over all inductive types, polynomial or not. Our induction rule is generic over the kinds of properties to be proved as well: like Hermida and Jacobs, we work in a general fibrational setting and so can accommodate very general notions of properties on inductive types rather than just those of particular syntactic forms. We establish the correctness of our generic induction rule by reducing induction to iteration. We show how our rule can be instantiated to give induction rules for the data types of rose trees, finite hereditary sets, and hyperfunctions. The former lies outside the scope of Hermida and Jacobs’ work because it is not polynomial; as far as we are aware, no induction rules have been known to exist for the latter two in a general fibrational framework. Our instantiation for hyperfunctions underscores the value of working in the general fibrational setting since this data type cannot be interpreted as a set
Generic Fibrational Induction
This paper provides an induction rule that can be used to prove properties of
data structures whose types are inductive, i.e., are carriers of initial
algebras of functors. Our results are semantic in nature and are inspired by
Hermida and Jacobs' elegant algebraic formulation of induction for polynomial
data types. Our contribution is to derive, under slightly different
assumptions, a sound induction rule that is generic over all inductive types,
polynomial or not. Our induction rule is generic over the kinds of properties
to be proved as well: like Hermida and Jacobs, we work in a general fibrational
setting and so can accommodate very general notions of properties on inductive
types rather than just those of a particular syntactic form. We establish the
soundness of our generic induction rule by reducing induction to iteration. We
then show how our generic induction rule can be instantiated to give induction
rules for the data types of rose trees, finite hereditary sets, and
hyperfunctions. The first of these lies outside the scope of Hermida and
Jacobs' work because it is not polynomial, and as far as we are aware, no
induction rules have been known to exist for the second and third in a general
fibrational framework. Our instantiation for hyperfunctions underscores the
value of working in the general fibrational setting since this data type cannot
be interpreted as a set.Comment: For Special Issue from CSL 201
Quantum Programming with Inductive Datatypes: Causality and Affine Type Theory
Inductive datatypes in programming languages allow users to define useful
data structures such as natural numbers, lists, trees, and others. In this
paper we show how inductive datatypes may be added to the quantum programming
language QPL. We construct a sound categorical model for the language and by
doing so we provide the first detailed semantic treatment of user-defined
inductive datatypes in quantum programming. We also show our denotational
interpretation is invariant with respect to big-step reduction, thereby
establishing another novel result for quantum programming. Compared to
classical programming, this property is considerably more difficult to prove
and we demonstrate its usefulness by showing how it immediately implies
computational adequacy at all types. To further cement our results, our
semantics is entirely based on a physically natural model of von Neumann
algebras, which are mathematical structures used by physicists to study quantum
mechanics
- …