Gabriel Alfredo Baum

A new approach for the prediction of end-to-end performance of multimedia streams

Since its conception, proof-carrying code (PCC) woke up the interest of the research community and several methods based on this technique were developed. This technique guarantees that untrusted programs run safely in a host machine. In a PCC framework, the code producer equips the produced code with a formal proof establishing that the code satisfies the consumers security policies. So, the code consumer only needs to verify such proof before the execution of the mobile code. On the other hand, static analysis is a technique useful for the production of the information required to construct the mentioned proof. Based on these two techniques, PCC and static analysis, we developed a framework that guarantees the safe execution of mobile code. This framework uses a high-level intermediate language to verify the security of the code. A control flow graph or an abstract syntax tree with type annotations could be used. Such intermediate representations of the code enable us to use static analysis techniques to generate and verify the type information needed. Moreover, we implemented a prototype as a proof of concept for our framework.

Reasoning about static and dynamic properties in alloy: A purely relational approach

We study a number of restrictions associated with the first-order relational specification language Alloy. The main shortcomings we address are:---the lack of a complete calculus for deduction in Alloys underlying formalism, the so called relational logic,---the inappropriateness of the Alloy language for describing (and analyzing) properties regarding execution traces.The first of these points was not regarded as an important issue during the genesis of Alloy, and therefore has not been taken into account in the design of the relational logic. The second point is a consequence of the static nature of Alloy specifications, and has been partly solved by the developers of Alloy; however, their proposed solution requires a complicated and unstructured characterization of executions.We propose to overcome the first problem by translating relational logic to the equational calculus of fork algebras. Fork algebras provide a purely relational formalism close to Alloy, which possesses a complete equational deductive calculus. Regarding the second problem, we propose to extend Alloy by adding actions. These actions, unlike Alloy functions, do modify the state. Much the same as programs in dynamic logic, actions can be sequentially composed and iterated, allowing them to state properties of execution traces at an appropriate level of abstraction.Since automatic analysis is one of Alloys main features, and this article aims to provide a deductive calculus for Alloy, we show that:---the extension hereby proposed does not sacrifice the possibility of using SAT solving techniques for automated analysis,---the complete calculus for the relational logic is straightforwardly extended to a complete calculus for the extension of Alloy.

On the Smooth Calculation of Relational Recursive Expressions out of First-Order Non-Constructive Specifications Involving Quantifiers

The work presented here has its focus on the formal construction of programs out of non-constructive specifications involving quantifiers. This is accomplished by means of an extended abstract algebra of relations whose expressive power is shown to encompass that of first-order logic. Our extension was devised for tackling the classic issue of lack of expressiveness of abstract relational algebras first stated by Tarski and later formally treated by Maddux, Nemeti, etc. First we compare our extension with classic approaches to expressiveness and our axiomatization with modern approaches to products. Then, we introduce some non-fundamental operations. One of them, the relational implication, is shown to have heavy heuristic significance both in the statement of Galois connections for expressing relational counterparts for universally quantified sentences and for dealing with them. In the last sections we present two smooth program derivations based on the theoretical framework introduced previously.

From Specifications to Programs: A Fork-Algebraic Approach to Bridge the Gap

The development of programs from first-order specifications has as its main difficulty that of dealing with universal quantifiers. This work is focused in that point, i.e., in the construction of programs whose specifications involve universal quantifiers. This task is performed within a relational calculus based on fork algebras. The fact that first-order theories can be translated into equational theories in abstract fork algebras suggests that such work can be accomplished in a satisfactory way. Furthermore, the fact that these abstract algebras are representable guarantees that all properties valid in the standard models are captured by the axiomatization given for them, allowing the reasoning formalism to be shifted back and forth between any model and the abstract algebra. In order to cope with universal quantifiers, a new algebraic operation — relational implication — is introduced. This operation is shown to have deep significance in the relational statement of first-order expressions involving universal quantifiers. Several algebraic properties of the relational implication are stated showing its usefulness in program calculation. Finally, a non-trivial example of derivation is given to asses the merits of the relational implication as an specification tool, and also in calculation steps, where its algebraic properties are clearly appropriate as transformation rules.

Foundations of Object-Oriented Modeling Notations in a Dynamic Logic Framework

The Unified Modeling Language UML is a language for specifying object-oriented systems. It is a standard in the domain of object-oriented analysis and design. Due to the missing formal foundation of the UML the syntax and the semantics of a number of UML costructs are not precisely defined.

Dependency Relations between Models in the Unified Process

The goal of the Unified Process is to guide developers in efficiently implementing and deploying systems that meet customer needs. During the Unified Process, a variety of models of the system are developed. All these models are not independent, they are related to each other. Elements in one model have trace dependencies to other models: they are semantically overlapping and together represent the system as a whole. It is necessary to have a precise definition of the syntax and semantics of the different models and their relationships, since the lack of accuracy in their definition can lead to wrong model interpretations and inconsistency between models. We distinguish three different kinds of dependency relations between models and propose a formal description of them. The goal of the proposed formalization is to provide formal foundations for tools that perform intelligent analysis on models expressed in UML assisting software engineers throughout the development process.

Formal foundations of object-oriented modeling notations

Describes and classifies the different solutions that have been proposed to realize the integration of graphic modeling languages, which are known and accepted by software developers, with formal modeling languages having analysis and verification tools. Inspired by that classification, we define a new integration proposal, based on first-order dynamic logic. The principal benefits of the proposed formalization can be summarized as follows. (i) The different views of a system are integrated in a single formal model; this allows us to define compatibility rules between the separate views, on both a syntactic and a semantic level. (ii) Using formal manipulation, it is possible to deduce further knowledge from the specification. (iii) Faults in the specifications, expressed using a user-friendly notation, can be revealed using analysis and verification techniques based on the formal kernel model. The principal difference between this model and other object-oriented formal models is that it integrates both of the levels in the modeling notation architecture into a single conceptual framework. The integration of modeling entities and modeled entities into a single formalism allows us to express both static and dynamic aspects of either the model or the modeled system within a first-order formalism.

Taking Alloy to the Movies

We present a modified semantics and an extension of the Alloy specification language. The results presented in this paper are: (a) We show how the modified semantics of Alloy allows us to avoid the higher-order quantification currently used both in the composition of operations and in specifications, keeping the language first-order. (b) We show how the extended language, which includes features from dynamic logic, enables a cleaner (with respect to previous papers) treatment of properties of executions. (c) We show that the automatic analysis currently available for Alloy specifications can be fully applied in the analysis of specifications under the new semantics. (d) We present a calculus for the extended language that is complete with respect to the extended semantics. This allows us to complement the analysis currently provided in Alloy with theorem proving. (e) Finally, we show how to use the theorem prover PVS in order to verify Alloy specifications.

A Logic for Real-Time Systems Specification, Its Algebraic Semantics, and Equational Calculus

We present a logic for real time systems specification which is an extension of first order dynamic logic by adding (a) arbitrary atomic actions rather than only assignments, (b) variables over actions which allow to specify systems partially, and (c) explicit time. The logic is algebraized using closure fork algebras and a representation theorem for this class is presented. This allows to define an equational (but infinitary) proof system for the algebraization.

Representability and program construction within fork algebras

The representation theorem for fork algebras was always misunderstood regarding its applications in program construction. Its application was always described as “the portability of properties of the problem domain into the abstract calculus of fork algebras”. In this paper we show that the results provided by the representation theorem are by far more important. We show that not only the heuristic power coming from concrete binary relations is captured inside the abstract calculus, but also design strategies for program development can be successfully expressed. This result makes fork algebras a programming calculus by far more powerful than it was previously thought.