1,721,036 research outputs found
pi_RA: A pi-calculus for Verifying Protocols that Use Remote Attestation
No full textRemote attestation (RA) is a primitive that allows the authentication of software components on untrusted systems by relying on a root of trust. Network protocols can use the primitive to establish trust in remote software components they communicate with. As such, RA can be regarded as a first-class security primitive like (a)symmetric encryption, message authentication, etc. However, current formal models of RA do not allow analysing protocols that use the primitive without tying them to specific platforms, low-level languages, memory protection models, or implementation details. In this paper, we propose and demonstrate a new model, called pi_RA, that supports RA at a high level of abstraction by treating it as a cryptographic primitive in a variant of the applied pi-calculus. To demonstrate the use of pi_RA, we use it to formalise and analyse the security of MAGE, an SGX-based framework that allows mutual attestation of multiple enclaves. The protocol is formalised in the form of a compiler that implements actor-based communication primitives in a source language (pi_Actor) in terms of remote attestation primitives in pi_RA. Our security analysis uncovers a caveat in the security of MAGE that was left unmentioned in the original paper.sponsorship: Air Force Office of Scientific Research|FA9550-21-1-0054status: Publishe
Fully abstract from static to gradual
Full text linksponsorship: This work was funded in part by Internal Funds KU Leuven grant C14/18/064. Amin Timany was a postdoctoral fellow of the Flemish research fund (FWO) during parts of this project. This material is based upon work supported by the Air Force Office of Scientific Research under award number FA9550-21-1-0054. This work was partly supported by the Fund for Scientific Research -Flanders (FWO). (Internal Funds KU Leuven|C14/18/064, Air Force Office of Scientific Research|FA9550-21-1-0054, Fund for Scientific Research - Flanders (FWO))status: Published onlin
Going Beyond Counting First Authors in Author Co-citation Analysis
Full text linkThe present study examines one of the fundamental aspects of author co-citation analysis (ACA) - the way co-citation
counts are defined. Co-citation counting provides the data on which all subsequent statistical analyses and mappings
are based, and we compare ACA results based on two different types of co-citation counting - the traditional type that
only counts the first one among a cited work's authors on the one hand and a non-traditional type that takes into
account the first 5 authors of a cited work on the other hand. Results indicate that the picture produced through this non-traditional author co-citation counting contains more coherent author groups and is therefore considerably clearer. However, this picture represents fewer specialties in the research field being studied than that produced through the traditional first-author co-citation counting when the same number of top-ranked authors is selected and analyzed. Reasons for these effects are discussed
Variations on the Author
Full text link“Variations on the Author” discusses two of Eduardo Coutinho’s recent films (Um Dia na Vida, from 2010, and Últimas Conversas, posthumously released in 2015) and their contribution to the general question of documentary authorship. The director’s filmography is characterized by a consistent yet self-effacing form of authorial self-inscription: Coutinho often features as an interviewer that rather than express opinions propels discourses; an interviewer that is good at listening. This mode of self-inscription characterizes him as an author who is not expressive but who is nonetheless markedly present on the screen. In Um Dia na Vida, however, Coutinho is completely absent form the image, while Últimas Conversas, on the contrary, includes a confessional prologue that moves the director from the margins to the center of his films. This article examines the ways in which these works stand out in the filmography of a director who offers new insights into the notion of cinematic authorship
Appropriate Similarity Measures for Author Cocitation Analysis
Full text linkWe provide a number of new insights into the methodological discussion about author cocitation analysis. We first argue that the use of the Pearson correlation for measuring the similarity between authors’ cocitation profiles is not very satisfactory. We then discuss what kind of similarity measures may be used as an alternative to the Pearson correlation. We consider three similarity measures in particular. One is the well-known cosine. The other two similarity measures have not been used before in the bibliometric literature. Finally, we show by means of an example that our findings have a high practical relevance.information science;Pearson correlation;cosine;similarity measure;author cocitation analysis
Bijdragen aan multimodus- en preschooftypetheorie
No full textDependent type theory is a powerful logic for both secure programming and computer assisted proving about programs. Dependently typed languages such as Agda, Coq and Idris can therefore be used both as programming languages and as proof assistants.
The goal of this PhD project is to establish directed dependent type theories (DDTT) by formulating them, implementing them, proving their consistency and demonstrating their use. By a DDTT, we mean a dependent type theory which has not only a built-in notion of equality, but also of structure preserving transformation.
By including the notion of structure preservation in the foundations of the system, rather than defining it on an ad-hoc basis as is done in classical mathematics, we expect to obtain many theorems (including all parametricity theorems) and even some operations for free. For example, when we define a functorial type former, such as List, we expect its functorial action (fmap) to be implemented automatically. This is especially useful when reasoning about or programming with more complicated concepts, such as monad transformations, which implement the effects of one monad in terms of another, or transformations between mathematical structures.
DDTT will also give us a better understanding of subtyping in the context of dependent types. This is of particular interest for the programming language Scala, which has subtyping at its core and was recently extended with some basic support for dependent types.status: Publishe
Afhankelijke patroonherkenning en bewijs-relevante unificatie
No full textDependent type theory is a powerful language for writing functional programs
with very precise types. It is used to write not only programs but also
mathematical proofs that these programs satisfy certain properties. Because of
this, languages based on dependent types – such as Coq, Agda, and Idris – are
used both as programming languages and as interactive proof assistants.
While dependent types give strong guarantees about your programs and proofs,
they also impose equally strong requirements on them. This often makes it
harder to write programs in a dependently typed language compared to one with
a simpler type system. For this reason certain techniques have been developed,
such as dependent pattern matching and specialization by unification. These
techniques provide an intuitive way to write programs and proofs in dependently
typed languages.
Previously, dependent pattern matching had only been shown to work in
a limited setting. In particular, it relied on the K axiom – also known as
the uniqueness of identity proofs – to remove equations of the form x = x.
This axiom is inadmissible in many type theories, particularly in the new and
promising branch known as homotopy type theory (HoTT). As a result, programs
and proofs in these new theories cannot make use of dependent pattern matching
and are as a result much harder to write, modify, and understand. Additionally,
the interaction of dependent pattern matching with small but practical features
such as eta-equality for record types and postponing of unification constraints
was poorly understood, resulting in subtle bugs and inconsistencies.
In this thesis, we develop dependent pattern matching and unification in a
general setting that does not require the K axiom, both from a theoretical
perspective and a practical one. In particular, we present a proof-relevant
unification algorithm, where each unification rule produces evidence of its
correctness. This evidence guarantees that all unification rules are correct by
construction, and also gives a computational characterization to each unification
rule.
To ensure that these techniques are sound and will stay so in face of future
extensions to type theory, we show how to translate them to more basic primitive
constructs, i.e. the standard datatype eliminators. During this translation, we
pay special attention to the computational content of all constructions involved.
This guarantees that the intuitions from regular pattern matching carry over to
a dependently typed setting.
Based on our work, we implemented a complete overhaul of the algorithm
for checking definitions by dependent pattern matching in Agda. Our new
implementation fixes a substantial number of issues in the old implementation,
and is at the same time less restrictive than the old ad-hoc restrictions. Thus it
puts the whole system back on a strong foundation. In addition, our work has
already been used as the basis for other implementations of dependent pattern
matching, such as the Equations package for Coq and the Lean theorem prover.
The work in this thesis eliminates all implicit assumptions introduced to the
type theory by pattern matching and unification. In the future, we may also
want to integrate new principles with pattern matching, for example the higher
inductive types introduced by HoTT. The framework presented in this thesis
also provides a solid basis for such extensions to be built on.status: Publishe
Multitier functioneel reactief programmeren voor het web
No full textWeb applications are inherently distributed, and not just because their client and server counterparts run on networked systems.
Web applications are written in multiple programming languages and as multiple programs: the server and client programs.
In an effort to lower the complexity of the web, multi-tier programming was proposed.
In multi-tier programming languages the language and its tooling give support to create web applications as a whole, one program is written in one language.
Web applications are also inherently asynchronous.
On the server, they constantly process several client requests and in the browser they constantly have to react to input, be it from the user or a server.
A technique that can be applied to make such programs easier to understand is functional reactive programming.
A functional programming model that models an interactive program as compositions between two primitives, behaviors and events.
In this research, we apply and combine both techniques to web applications, making advances in both applying multi-tier programming to existing languages and to functional reactive programming.
We show that the whole of multi-tier and functional reactive programming is greater than the sum of its parts with new properties as a result.
Multi-tier Functional Reactive Programming
Multi-tier FRP is our unification of multi-tier programming and functional reactive programming.
It tackles two problems in development, (1) the inherent distributed and (2) the asynchronous nature of the web.
With our design and implementation it becomes possible to write an entire web application (both client and server) in a single language as a composition between events and behaviors.
Communication between client and server tier is done through tier-crossing primitives, a low-cost abstraction with atomic propagation.
They are checked at the language level and make sure client and server are compatible.
We present Gavial, a usable and realistic implementation of multi-tier FRP in Scala as a library that builds on several other techniques to become viable, several of which we describe throughout this dissertation:
FRP DOM APIs are key to making a usable FRP web framework.
However, subtle design decisions have a big impact and certain issues do not necessarily have an ideal solution.
What should be the entry point of the program?
How do we deal with recursive definitions in HTML?
The user interface is expressed in terms of itself, for example, a todo-list adds rows depending on the interaction with itself.
How do we interface with the DOM?
The DOM is both a producer of events and a storage of state.
We look at these questions and implement a pragmatic FRP DOM API that is used in Gavial.
Scalagna is our multi-tier-as-a-library project for Scala.
There are several potential problems with multi-tier language development.
Certain languages start from scratch and have a hard time covering all library use cases of mature language ecosystems, others start from an existing language but have a high implementation cost on client compilation, etc.
We present Scalagna, a first step towards multi-tier programming for Scala.
It takes advantage of Scala.JS, a mature Scala to JavaScript compiler with its own ecosystem of libraries.
Incremental behaviors are an additional FRP primitive.
State that is incrementally modified is common in web applications, a user that interacts with a program constantly changes its state with each form of input.
In an FRP setting these states are modeled using behaviors, but traditional FRP exposes no information on why or when these behaviors change.
This information becomes crucial in a multi-tier FRP setting, where incremental data structures can become large (e.g., through multiple user interaction).
Such large data structures are required to be processed efficiently, possibly in terms of computation but definitely in terms of bandwidth.
To make this information available in multi-tier FRP, we present incremental behaviors.
A behavior that describes why and when it changes its value so that they can be sent across the network efficiently.status: Publishe
Dispelling the Myths Behind First-author Citation Counts
Full text linkWe conducted a full-scale evaluative citation analysis study of scholars in the XML research field to explore just how different from each other author rankings resulting from different citation counting methods actually are, and to demonstrate the capability of emerging data and tools on the Web in supporting more realistic citation counting methods. Our results contest some common arguments for the continued
use of first-author citation counts in the evaluation of scholars, such as high correlations between author rankings by first-author citation counts and other citation
counting methods, and high costs of using more realistic citation counting methods that are not well-supported by the ISI databases. It is argued that increasingly available digital full text research papers make it possible for citation analysis studies to go beyond what the ISI databases have directly supported and to employ more
sophisticated methods
- …
