pinecone/core-2020-05-10-deduplication huggingface dataset:
Consumedia. Functionalities, emotion detection and automation of services in a ODR Platform

This paper presents a legal and technological approach to online mediation. It shows the technologies that are usually employed in this field and presents the prototype of Consumedia, an online mediation platform, as well as its functionalities and technological architecture. Moreover, it uncovers the technology implemented as regards the recognition of emotions in the mediation room. Furthermore, it considers that an online mediation platform may au-tomatically provide the parties with all the required documentation of the process. Thus, it unveils the documents that an online mediation platform should automatically provide to the disputants
Crowdsourcing tools for disaster management : a review of platforms and methods

Recent advances on information technologies and communica-tions, coupled with the advent of the social media applications have fuelled a new landscape of emergency and disaster response systems by enabling affect-ed citizens to generate georeferenced real time information on critical events. The identification and analysis of such events is not straightforward and the ap-plication of crowdsourcing methods or automatic tools is needed for that pur-pose. Whereas crowdsourcing makes emphasis on the resources of people to produce, aggregate, or filter original data, automatic tools make use of infor-mation retrieval techniques to analyze publicly available information. This pa-per reviews a set of online tools and platforms implemented in recent years which are currently being applied in the area of emergency management and proposes a taxonomy for its categorization
A method for defining human-machine micro-task workflows for gathering legal information

Series : Lecture notes in computer science, ISSN 0302-9743, vol. 8929With the growing popularity of micro-task crowdsourcing platforms, new workflow-based micro-task crowdsourcing approaches are starting to emerge. Such workflows occur in legal, political and conflict resolution do-mains as well, presenting new challenges, namely in micro-task specification and human-machine interaction, which result mostly from the flow of unstruc-tured data. Domain ontologies provide the structure and semantics required to describe the data flowing throughout the workflow in a way understandable to both humans and machines. This paper presents a method for the construction of micro-task workflows from legal domain ontologies. The method is currently being employed in the context of the UMCourt project in order to formulate in-formation retrieval and conflict resolution workflows.This work is part-funded by FEDER Funds, by the ERDF (Eu-ropean Regional Development Fund) through the COMPETE Programme (operation-al programme for competitiveness) and by National Funds through the FCT (Portu-guese Foundation for Science and Technology) within the project FCOMP-01-0124-FEDER-028980 (PTDC/EEI-SII/1386/2012). The work of Nuno Luz is supported by the doctoral grant SFRH/BD/70302/2010
Drafting a composite indicator of validity for regulatory models and legal systems

The aim of this paper is to lay the groundwork for the creation of a composite indicator of the validity of regulatory systems. The composite nature of the indicator implies a) that its construction is embedded in the long-standing theoretical debate and framework of legal validity; b) that it formally contains other sub-indicators whose occurrence is essential to the determination of validity. The paper suggests, in other words, that validity is a second-degree property, i.e., one that occurs only once the justice, efficiency, effectiveness, and enforceability of the system have been checked
Tri-level Multi-follower Decision Making

© Springer-Verlag Berlin Heidelberg 2015. In a tri-level hierarchical decision problem, each decision entity at one level has its objective, constraints and decision variables affected in part by the decision entities at the other two levels. The choice of values for its variables may allow it to influence the decisions made at other levels, and thereby improve its own objective. We called this a tri-level decision problem. When multiple decision entities are involved at the middle and bottom levels, the top-level entity’s decision will be affected not only by these followers’ individual reactions but also by the relationships among the followers. We call this problem a tri-level multi-follower (TLMF) decision
Debugging Process Algebra Specifications

International audienceDesigning and developing distributed and concurrent applications has always been a tedious and error-prone task. In this context, formal techniques and tools are of great help in order to specify such concurrent systems and detect bugs in the corresponding models. In this paper, we propose a new framework for debugging value-passing process algebra through coverage analysis. We illustrate our approach with LNT, which is a recent specification language designed for formally modelling concurrent systems. We define several coverage notions before showing how to instrument the specification without affecting original behaviors. Our approach helps one to improve the quality of a dataset of examples used for validation purposes, but also to find ill-formed decisions, dead code, and other errors in the specification. We have implemented a tool for automating our debugging approach, and applied it to several real-world case studies in different application areas
Urban context detection and context-aware recommendation via networks of "humans as sensors"

The wide adoption of smart mobile devices makes the concept of human as a sensor possible, opening the door to new ways of solving recurrent problems that occur in everyday life by taking advantage of the information these devices can produce. In the case of this paper, we present part of the work done in the EU project SUPERHUB and introduce how geolocated positioning coming from such devices can be used to infer the current context of the city, e.g., disruptive events, and how this information can be used to provide services to the end-users.Peer ReviewedPostprint (author’s final draft
Localization and Entanglement in Relativistic Quantum Physics

The combination of quantum theory and special relativity leads to structures
that differ in several respects from non-relativistic quantum mechanics of
particles. These differences are quite familiar to practitioners of Algebraic
Quantum Field Theory but less well known outside this community. The paper is
intended as a concise survey of some selected aspects of relativistic quantum
physics, in particular regarding localization and entanglement.Comment: For the proceedings of the workshop "The Message of Quantum Science
  -- Attempts Towards a Synthesis" held at ZIF, Bielefeld, February-March 201
Secure Efficient History-Hiding Append-Only Signatures in the Standard Model

International audienceAs formalized by Kiltz et al. (ICALP '05), append-only signatures (AOS) are digital signature schemes where anyone can publicly append extra message blocks to an already signed sequence of messages. This property is useful, e.g., in secure routing, in collecting response lists, reputation lists, or petitions. Bethencourt, Boneh and Waters (NDSS '07) suggested an interesting variant, called history-hiding append-only signatures (HH-AOS), which handles messages as sets rather than ordered tuples. This HH-AOS primitive is useful when the exact order of signing needs to be hidden. When free of subliminal channels (i.e., channels that can tag elements in an undetectable fashion), it also finds applications in the storage of ballots on an electronic voting terminals or in other archival applications (such as the record of petitions, where we want to hide the influence among messages). However, the only subliminal-free HH-AOS to date only provides heuristic arguments in terms of security: Only a proof in the idealized (non-realizable) random oracle model is given. This paper provides the first HH-AOS construction secure in the standard model. Like the system of Bethencourt et al., our HH-AOS features constant-size public keys, no matter how long messages to be signed are, which is atypical (we note that secure constructions often suffer from a space penalty when compared to their random-oracle-based counterpart). As a second result, we show that, even if we use it to sign ordered vectors as in an ordinary AOS (which is always possible with HH-AOS), our system provides considerable advantages over existing realizations. As a third result, we show that HH-AOS schemes provide improved identity-based ring signatures (i.e., in prime order groups and with a better efficiency than the state-of-the-art schemes)
A linked data framework for Android

International audienceMobile devices are becoming major repositories of personal information. Still, they do not provide a uniform manner to deal with data from both inside and outside the device. Linked data provides a uniform interface to access structured interconnected data over the web. Hence, exposing mobile phone information as linked data would improve the usability of such information. We present an API that provides data access in RDF, both within mobile devices and from the outside world. This API is based on the Android content provider API which is designed to share data across Android applications. Moreover, it introduces a transparent URI dereferencing scheme, exposing content outside of the device. As a consequence, any application may access data as linked data without any a priori knowledge of the data source
Linked data and linked APIs: similarities, differences, and challenges

In an often retweeted Twitter post, entrepreneur and software architect Inge Henriksen described the relation of Web 1.0 to Web 3.0 as: “Web 1.0 connected humans with machines. Web 2.0 connected humans with humans. Web 3.0 connects machines with machines.”\ud
On the one hand, an incredible amount of valuable data is described by billions of triples, machine-accessible and interconnected thanks to the promises of Linked Data. On the other hand, rest is a scalable, resourceoriented\ud
architectural style that, like the Linked Data vision, recognizes the importance of links between resources. Hypermedia apis are resources, too—albeit dynamic ones—and unfortunately, neither Linked Data principles, nor the rest-implied self-descriptiveness of hypermedia\ud
apis sufficiently describe them to allow for long-envisioned realizations like automatic service discovery and composition. We argue that describing inter-resource links—similarly to what the Linked Data movement\ud
has done for data—is the key to machine-driven consumption of apis. In this paper, we explain how the description format restdesc captures the functionality of apis by explaining the effect of dynamic interactions,\ud
effectively complementing the Linked Data vision.Peer ReviewedPostprint (author's final draft
Type-based allocation analysis for co-recursion in lazy functional languages

This paper presents a novel type-and-effect analysis for pre-dicting upper-bounds on memory allocation costs for co-recursive def-initions in a simple lazily-evaluated functional language. We show thesoundness of this system against an instrumented variant of Launch-bury’s semantics for lazy evaluation which serves as a formal cost model.Our soundness proof requires an intermediate semantics employing indi-rections. Our proof of correspondence between these semantics that weprovide is thus a crucial part of this work.The analysis has been implemented as an automatic inference system.We demonstrate its effectiveness using several example programs thatpreviously could not be automatically analysed.Postprin
A Verified Compiler for Probability Density Functions

Bhat et al. developed an inductive compiler that computes density functions
for probability spaces described by programs in a simple probabilistic
functional language. In this work, we implement such a compiler for a modified
version of this language within the theorem prover Isabelle and give a formal
proof of its soundness w.r.t. the semantics of the source and target language.
Together with Isabelle's code generation for inductive predicates, this yields
a fully verified, executable density compiler. The proof is done in two steps,
using a standard refinement approach: first, an abstract compiler working with
abstract functions modelled directly in the theorem prover's logic is defined
and proven sound. Then, this compiler is refined to a concrete version that
returns a target-language expression.Comment: Presented at ESOP 201
Model-Based Adaptation of Software Communicating via FIFO Buffers

International audienceSoftware Adaptation is a non-intrusive solution for composing black-box components or services (peers) whose individual func-tionality is as required for the new system, but that present interface mismatch, which leads to deadlock or other undesirable behaviour when combined. Adaptation techniques aim at automatically generating new components called adapters. All the interactions among peers pass through the adapter, which acts as an orchestrator and makes the involved peers work correctly together by compensating for mismatch. Most of the existing solutions in this field assume that peers interact synchronously using rendezvous communication. However, many application areas rely on asynchronous communication models where peers interact exchanging messages via buffers. Generating adapters in this context becomes a difficult problem because peers may exhibit cyclic behaviour, and their composition often results in infinite systems. In this paper, we present a method for automatically generating adapters in asynchronous environments where peers interact using FIFO buffers
Exploring scenario exploration

Model ﬁnders are very popular for exploring scenarios, helping users validate speciﬁcations by navigating through conforming model instances. To be practical, the semantics of such scenario exploration operations should be formally deﬁned and, ideally, controlled by the users, so that they are able to quickly reach interesting scenarios. This paper explores the landscape of scenario exploration operations, by formalizing them with a relational model ﬁnder. Several scenario exploration operations provided by existing tools are formalized, and new ones are proposed, namely to allow the user to easily explore very similar (or diﬀerent) scenarios, by attaching preferences to model elements. As a proof-of-concept, such operations were implemented in the popular Alloy Analyzer, further increasing its usefulness for (user-guided) scenario exploration.North Portugal Regional Operational Programme (ON.2 – O Novo Norte), under the National Strategic Reference Framework (NSRF), through the European Regional Development Fund (ERDF), within project NORTE-07-0124-FEDER-000062
Knowledge = Observation + Memory + Computation

International audienceWe compare three notions of knowledge in concurrent system: mem-oryless knowledge, knowledge of perfect recall, and causal knowledge. Mem-oryless knowledge is based only on the current state of a process, knowledge of perfect recall can take into account the local history of a process, and causal knowledge depends on the causal past of a process, which comprises the information a process can obtain when all processes exchange the information they have when performing joint transitions. We compare these notions in terms of knowledge strength, number of bits required to store this information, and the complexity of checking if a given process has a given knowledge. We show that all three notions of knowledge can be implemented using finite memory. Causal knowledge proves to be strictly more powerful than knowledge with perfect recall , which in turn proves to be strictly more powerful than memoryless knowledge. We show that keeping track of causal knowledge is cheaper than keeping track of knowledge of perfect recall
Step-Indexed Logical Relations for Probability (long version)

It is well-known that constructing models of higher-order probabilistic
programming languages is challenging. We show how to construct step-indexed
logical relations for a probabilistic extension of a higher-order programming
language with impredicative polymorphism and recursive types. We show that the
resulting logical relation is sound and complete with respect to the contextual
preorder and, moreover, that it is convenient for reasoning about concrete
program equivalences. Finally, we extend the language with dynamically
allocated first-order references and show how to extend the logical relation to
this language. We show that the resulting relation remains useful for reasoning
about examples involving both state and probabilistic choice.Comment: Extended version with appendix of a FoSSaCS'15 pape
Game Semantics and Normalization by Evaluation

International audienceWe show that Hyland and Ong's game semantics for PCF can be presented using normalization by evaluation (nbe). We use the bijective correspondence between innocent well-bracketed strategies and PCF Böhm trees, and show how operations on PCF Böhm trees, such as composition, can be computed lazily and simply by nbe. The usual equations characteristic of games follow from the nbe construction without reference to low-level game-theoretic machinery. As an illustration, we give a Haskell program computing the application of innocent strategies
Approximate counting in SMT and value estimation for probabilistic programs

SMT, or model counting for logical theories, is a well known hard problem that generalizes such tasks as counting the number of satisfying assignments to a Boolean formula and computing the volume of a polytope. In the realm of satisfiability modulo theories (SMT) there is a growing need for model counting solvers, coming from several application domains (quantitative information flow, static analysis of probabilistic programs). In this paper, we show a reduction from an approximate version of #SMT to SMT. We focus on the theories of integer arithmetic and linear real arithmetic. We propose model counting algorithms that provide approximate solutions with formal bounds on the approximation error. They run in polynomial time and make a polynomial number of queries to the SMT solver for the underlying theory, exploiting “for free” the sophisticated heuristics implemented within modern SMT solvers. We have implemented the algorithms and used them to solve a value estimation problem for a model of loop-free probabilistic programs with nondeterminism.Peer-reviewedPost-printTools and Algorithms for the Construction and Analysis of Systems 21st International Conference, TACAS 2015 Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2015 London, U
Fairness for Infinite-State Systems

See also Research Note RN/14/11 UCL Department of Computer Science.In this paper we introduce the first known tool for symbolically proving fair-CTL properties of (infinite-state) integer programs. Our solution is based on a reduction to existing techniques for fairness- free CTL model checking via the use of infinite non-deterministic branching to symbolically partition fair from unfair executions. We show the viability of our approach in practice using examples drawn from device drivers and algorithms utilizing shared resources.Peer-reviewedPost-print21st International Conference on Tools and Algorithms for the Construction and Analysis of Systems, London, U
AutoProof: Auto-active Functional Verification of Object-oriented
  Programs

Auto-active verifiers provide a level of automation intermediate between
fully automatic and interactive: users supply code with annotations as input
while benefiting from a high level of automation in the back-end. This paper
presents AutoProof, a state-of-the-art auto-active verifier for object-oriented
sequential programs with complex functional specifications. AutoProof fully
supports advanced object-oriented features and a powerful methodology for
framing and class invariants, which make it applicable in practice to idiomatic
object-oriented patterns. The paper focuses on describing AutoProof's
interface, design, and implementation features, and demonstrates AutoProof's
performance on a rich collection of benchmark problems. The results attest
AutoProof's competitiveness among tools in its league on cutting-edge
functional verification of object-oriented programs
Non-Cumulative Resource Analysis (Author’s version)

Existing cost analysis frameworks have been defined for cumulative resources which keep on increasing along the computation. Traditional cumulative resources are execution time, number of executed steps, amount of memory allocated, and energy consumption. Noncumulative resources are acquired and (possibly) released along the execution. Examples of non-cumulative cost are memory usage in the presence of garbage collection, number of connections established that are later closed, or resources requested to a virtual host which are released after using them. We present, to the best of our knowledge, the first generic static analysis framework to infer an upper bound on the peak cost for non-cumulative types of resources. Our analysis comprises several components: (1) a pre-analysis to infer when resources are being used simultaneously, (2) a program-point resource analysis which infers an upper bound on the cost at the points of interest (namely the points where resources are acquired) and (3) the elimination from the upper bounds obtained in (2) of those resources accumulated that are not used simultaneously. We report on a prototype implementation of our analysis that can be used on a simple imperative language
Using a Formal Model to Improve Verification of a Cache-Coherent System-on-Chip

International audienceIn this paper we report about a case study on the functional verification of a System-on-Chip (SoC) with a formal system-level model. Our approach improves industrial simulation-based verification techniques in two aspects. First, we suggest to use the formal model to assess the sanity of an interface verification unit. Second, we present a two-step approach to generate clever semi-directed test cases from temporal logic properties: model-based testing tools of the CADP toolbox generate system-level abstract test cases, which are then refined with a commercial Coverage-Directed Test Generation tool into interface-level concrete test cases that can be executed at RTL level. Applied to an AMBA 4 ACE-based cache-coherent SoC, we found that our approach helps in the transition from interface-level to system-level verification, facilitates the validation of system-level properties, and enables early detection of bugs in both the SoC and the commercial test-bench
Direct Construction of Recursive MDS Diffusion Layers using Shortened BCH Codes

Best paper awardInternational audienceMDS matrices allow to build optimal linear diffusion layers in block ciphers. However, MDS matrices cannot be sparse and usually have a large description, inducing costly software/hardware implementations. Recursive MDS matrices allow to solve this problem by focusing on MDS matrices that can be computed as a power of a simple companion matrix, thus having a compact description suitable even for constrained environ- ments. However, up to now, finding recursive MDS matrices required to perform an exhaustive search on families of companion matrices, thus limiting the size of MDS matrices one could look for. In this article we propose a new direct construction based on shortened BCH codes, al- lowing to efficiently construct such matrices for whatever parameters. Unfortunately, not all recursive MDS matrices can be obtained from BCH codes, and our algorithm is not always guaranteed to find the best matrices for a given set of parameters