122 research outputs found
Axioms and Decidability for Type Isomorphism in the Presence of Sums
We consider the problem of characterizing isomorphisms of types, or,
equivalently, constructive cardinality of sets, in the simultaneous presence of
disjoint unions, Cartesian products, and exponentials. Mostly relying on
results about polynomials with exponentiation that have not been used in our
context, we derive: that the usual finite axiomatization known as High-School
Identities (HSI) is complete for a significant subclass of types; that it is
decidable for that subclass when two types are isomorphic; that, for the whole
of the set of types, a recursive extension of the axioms of HSI exists that is
complete; and that, for the whole of the set of types, the question as to
whether two types are isomorphic is decidable when base types are to be
interpreted as finite sets. We also point out certain related open problems
Ten virtues of structured graphs
This paper extends the invited talk by the first author about the virtues
of structured graphs. The motivation behind the talk and this paper relies on our
experience on the development of ADR, a formal approach for the design of styleconformant,
reconfigurable software systems. ADR is based on hierarchical graphs
with interfaces and it has been conceived in the attempt of reconciling software architectures
and process calculi by means of graphical methods. We have tried to
write an ADR agnostic paper where we raise some drawbacks of flat, unstructured
graphs for the design and analysis of software systems and we argue that hierarchical,
structured graphs can alleviate such drawbacks
Static Analysis of Concurrent Programs Based on Behavioral Type Systems
The strength of program static analysis techniques lies on its ability to detect faulty behaviors
prior to the execution.
This ability requires that the analysis process foresees any possible runtime scenario. A task which is even more complex in the case of concurrent programs, because of the number of alternatives introduced by the usual nondeterminism.
In this particular case, some of the most common faulty behaviors are those about erroneous usage of resources, presence of deadlocks and data race conflicts.
Behavioral type systems for programming languages provide a strong mechanism for reasoning on programs actions at static time. In this thesis we discuss two static analysis techniques based on this approach.
The first one, targets the resource usage in an ad-hoc
language with full-fledged operations for acquiring and releasing virtual machines. The second one,
targets the deadlock analysis of Java programs.
In both cases we provide a formal proof of correctness, along with prototype implementations that allow practically to test the feasibility of these solutions. These prototypes have also allowed assessing these techniques against others existing in the literature obtaining very encouraging results
Polymorphic systems with arrays : decidability and undecidability
Polymorphic systems with arrays (PSAs) is a general class of nondeterministic reactive systems. A PSA is polymorphic in the sense that it depends on a signature, which consists of a number of type variables, and a number of symbols whose types can be built from the type variables. Some of the state variables of a PSA can be arrays, which are functions from one type to another. We present several new decidability and undecidability results for parameterised control-state reachability problems on subclasses of PSAs
Logic in mathematics and computer science
Logic has pride of place in mathematics and its 20th century offshoot, computer science. Modern symbolic logic was developed, in part, as a way to provide a formal framework for mathematics: Frege, Peano, Whitehead and Russell, as well as Hilbert developed systems of logic to formalize mathematics. These systems were meant to serve either as themselves foundational, or at least as formal analogs of mathematical reasoning amenable to mathematical study, e.g., in Hilbertâs consistency program. Similar efforts continue, but have been expanded by the development of sophisticated methods to study the properties of such systems using proof and model theory. In parallel with this evolution of logical formalisms as tools for articulating mathematical theories (broadly speaking), much progress has been made in the quest for a mechanization of logical inference and the investigation of its theoretical limits, culminating recently in the development of new foundational frameworks for mathematics with sophisticated computer-assisted proof systems. In addition, logical formalisms developed by logicians in mathematical and philosophical contexts have proved immensely useful in describing theories and systems of
interest to computer scientists, and to some degree, vice versa. Three examples of the influence of logic in computer science are automated reasoning, computer verification, and type systems for programming languages
Repairing Type Errors in Functional Programs
Type systems for programming languages can be used by compilers to reject programs which are found to be unsound and which may, therefore, fail to execute successfully. When a program is rejected the programmer must repair it so that it can be type-checked correctly and then executed safely. Diagnostic error messages are essential to help the programmer repair the program.
Hindley-Milner type systems give the programmer a great deal of flexibility (polymorphism and implicit typing) while ensuring type safety. As a consequence of this flexibility repairing mistakes can be difficult and programmers have previously observed that type error messages produced by compilers are not helpful enough.
This thesis examines the problem of producing more helpful error messages for ill-typed programs written in programming languages with a Hindley-Milner typing discipline. Three main results are described. Firstly, type inference algorithms which infer types in different orders are described, and the ability of these to produce more meaningful error messages is investigated. Secondly, the results of several other authors on helping to explain type inference are condensed into a single generalisation. Thirdly, error messages which suggest concrete changes to the program to remove type errors are produced using the theory of linear type isomorphisms. This theory is implemented as an extension to the MLj compiler. Finally, extensions to Hindley-Milner are explored, taking the type system of MLj as an example
First steps in synthetic guarded domain theory: step-indexing in the topos of trees
We present the topos S of trees as a model of guarded recursion. We study the
internal dependently-typed higher-order logic of S and show that S models two
modal operators, on predicates and types, which serve as guards in recursive
definitions of terms, predicates, and types. In particular, we show how to
solve recursive type equations involving dependent types. We propose that the
internal logic of S provides the right setting for the synthetic construction
of abstract versions of step-indexed models of programming languages and
program logics. As an example, we show how to construct a model of a
programming language with higher-order store and recursive types entirely
inside the internal logic of S. Moreover, we give an axiomatic categorical
treatment of models of synthetic guarded domain theory and prove that, for any
complete Heyting algebra A with a well-founded basis, the topos of sheaves over
A forms a model of synthetic guarded domain theory, generalizing the results
for S
- âŠ