arXiv subjects

Giorgio Audrito

Publications and source records attributed to Giorgio Audrito.

At least 19 recordsLinked to original sources

arXiv2026

Exploiting Aggregate Programming in a Multi-Robot Service Prototype

Multi-robot systems are becoming increasingly relevant within diverse application domains, such as healthcare, exploration, and rescue missions. However, building such systems is still a significant challenge, since it adds the complexities of the physical nature of robots and their environments to those inherent in coordinating any distributed (multi-agent) system. Aggregate Programming (AP) has recently emerged as a promising approach to engineering resilient, distributed systems with proximity-based communication, and is notably supported by practical frameworks. In this paper we present a prototype of a multi-robot service system, which adopts AP for the design and implementation of its coordination software. The prototype has been validated both with simulations, and with tests in a University library.

cs.DC↗

arXiv2026

VinePT-Map: Pole-Trunk Semantic Mapping for Resilient Autonomous Robotics in Vineyards

Reliable long-term deployment of autonomous robots in agricultural environments remains challenging due to perceptual aliasing, seasonal variability, and the dynamic nature of crop canopies. Vineyards, characterized by repetitive row structures and significant visual changes across phenological stages, represent a pivotal field challenge, limiting the robustness of conventional feature-based localization and mapping approaches. This paper introduces VinePT-Map, a semantic mapping framework that leverages vine trunks and support poles as persistent structural landmarks to enable season-agnostic and resilient robot localization. The proposed method formulates the mapping problem as a factor graph, integrating GPS, IMU, and RGB-D observations through robust geometrical constraints that exploit vineyard structure. An efficient perception pipeline based on instance segmentation and tracking, combined with a clustering filter for outlier rejection and pose refinement, enables accurate landmark detection using low-cost sensors and onboard computation. To validate the pipeline, we present a multi-season dataset for trunk and pole segmentation and tracking. Extensive field experiments conducted across diverse seasons demonstrate the robustness and accuracy of the proposed approach, highlighting its suitability for long-term autonomous operation in agricultural environments.

cs.RO↗

arXiv2026

Lambdas at the Far Edge: a Tale of Flying Lambdas and Lambdas on Wheels

Aggregate Programming (AP) is a paradigm for programming the collective behaviour of sets of distributed devices, possibly situated at the network far edge, by relying on asynchronous proximity-based interactions. The eXchange Calculus (XC), a recently proposed foundational model for AP, is essentially a typed lambda calculus extended with an operator (the exchange operator) providing an implicit communication mechanism between neighbour devices. This paper provides a gentle introduction to XC and to its implementation as a C++ library, called FCPP. The FCPP library and toolchain has been mainly developed at the Department of Computer Science of the University of Turin, where Stefano Berardi spent most of his academic career conducting outstanding research about logical foundation of computer science and transmitting his passion for research to students and young researchers, often exploiting typed lambda calculi. An FCCP program is essentially a typed lambda term, and FCPP has been used to write code that has been deployed on devices at the far edge of the network, including rovers and (soon) Uncrewed Aerial Vehicles (UAVs); hence the title of the paper.

cs.DC↗

arXiv2024

Software Engineering for Collective Cyber-Physical Ecosystems

Today's distributed and pervasive computing addresses large-scale cyber-physical ecosystems, characterised by dense and large networks of devices capable of computation, communication and interaction with the environment and people. While most research focusses on treating these systems as "composites" (i.e., heterogeneous functional complexes), recent developments in fields such as self-organising systems and swarm robotics have opened up a complementary perspective: treating systems as "collectives" (i.e., uniform, collaborative, and self-organising groups of entities). This article explores the motivations, state of the art, and implications of this "collective computing paradigm" in software engineering, discusses its peculiar challenges, and outlines a path for future research, touching on aspects such as macroprogramming, collective intelligence, self-adaptive middleware, learning, synthesis, and experimentation of collective behaviour.

cs.SE↗

arXiv2024

Programming Distributed Collective Processes in the eXchange Calculus

Recent trends like the Internet of Things (IoT) suggest a vision of dense and multi-scale deployments of computing devices in nearly all kinds of environments. A prominent engineering challenge revolves around programming the collective adaptive behaviour of such computational ecosystems. This requires abstractions able to capture concepts like ensembles (dynamic groups of cooperating devices) and collective tasks (joint activities carried out by ensembles). In this work, we consider collections of devices interacting with neighbours and that execute in nearly-synchronised sense-compute-interact rounds, where the computation is given by a single program mapping sensing values and incoming messages to output and outcoming messages. To support programming whole computational collectives, we propose the abstraction of a distributed collective process, which can be used to define at once the ensemble formation logic and its collective task. We formalise the abstraction in the eXchange Calculus (XC), a core functional language based on neighbouring values (maps from neighbours to values) where state and interaction is handled through a single primitive, exchange, and provide a corresponding implementation in the FCPP language. Then, we exercise distributed collective processes using two case studies: multi-hop message propagation and distributed monitoring of spatial properties. Finally, we discuss the features of the abstraction and its suitability for different kinds of distributed computing applications.

cs.DC↗

arXiv2023

Computation Against a Neighbour: Addressing Large-Scale Distribution and Adaptivity with Functional Programming and Scala

Recent works in contexts like the Internet of Things (IoT) and large-scale Cyber-Physical Systems (CPS) propose the idea of programming distributed systems by focussing on their global behaviour across space and time. In this view, a potentially vast and heterogeneous set of devices is considered as an "aggregate" to be programmed as a whole, while abstracting away the details of individual behaviour and exchange of messages, which are expressed declaratively. One such a paradigm, known as aggregate programming, builds on computational models inspired by field-based coordination. Existing models such as the field calculus capture interaction with neighbours by a so-called "neighbouring field" (a map from neighbours to values). This requires ad-hoc mechanisms to smoothly compose with standard values, thus complicating programming and introducing clutter in aggregate programs, libraries and domain-specific languages (DSLs). To address this key issue we introduce the novel notion of "computation against a neighbour", whereby the evaluation of certain subexpressions of the aggregate program are affected by recent corresponding evaluations in neighbours. We capture this notion in the neighbours calculus (NC), a new field calculus variant which is shown to smoothly support declarative specification of interaction with neighbours, and correspondingly facilitate the embedding of field computations as internal DSLs in common general-purpose programming languages -- as exemplified by a Scala implementation, called ScaFi. This paper formalises NC, thoroughly compares it with respect to the classic field calculus, and shows its expressiveness by means of a case study in edge computing, developed in ScaFi.

cs.DC↗

arXiv2022

Predictive Semantics for Past-CTL Runtime Monitors

The distributed monitoring of swarms of devices cooperating to common global goals is becoming increasingly important, as such systems are employed for critical applications, e.g., in search and rescue missions during emergencies. In this paper, we target the distributed run-time verification of global properties of a swarm expressed as logical formulas in a temporal logic. In particular, for the implementation of decentralized monitors, we adopt the Field Calculus (FC) language, and exploit the results of previous works which have shown the possibility of automatically translating temporal logic formulas into FC programs. The main limitation of such works lies in the fact that the formulas are expressed in the past-CTL logic, which only features past modalities, and is therefore ineffective in predicting properties about the future evolution of a system. In this paper, we inject some limited prediction capability into the past-CTL logic by providing an extended semantics on a multi-valued logic, then assessing how this affects the automated translation into field calculus monitors.

cs.SE↗

arXiv2022

Aggregate Processes as Distributed Adaptive Services for the Industrial Internet of Things

The Industrial Internet of Things (IIoT) promises to bring many benefits, including increased productivity, reduced costs, and increased safety to new generation manufacturing plants. The main ingredients of IIoT are the connected, communicating devices directly located in the workshop floor (far edge devices), as well as edge gateways that connect such devices to the Internet and, in particular, to cloud servers. The field of Edge Computing advocates that keeping computations as close as possible to the sources of data can be an effective means of reducing latency, preserving privacy, and improve the overall efficiency of the system, although building systems where (far) edge and cloud nodes cooperate is quite challenging. In the present work we propose the adoption of the Aggregate Programming (AP) paradigm (and, in particular, the "aggregate process" construct) as a way to simplify building distributed, intelligent services at the far edge of an IIoT architecture. We demonstrate the feasibility and efficacy of the approach with simulated experiments on FCPP (a C++ library for AP), and with some basic experiments on physical IIoT boards running an ad-hoc porting of FCPP.

cs.SE↗

arXiv2021

Monotonic Filtering for Distributed Collection

Distributed data collection is a fundamental task in open systems. In such networks, data is aggregated across a network to produce a single aggregated result at a source device. Though self-stabilizing, algorithms performing data collection can produce large overestimates in the transient phase. For example, in [1] we demonstrated that in a line graph, a switch of sources after initial stabilization may produce overestimates that are quadratic in the network diameter. We also proposed monotonic filtering as a strategy for removing such large overestimates. Monotonic filtering prevents the transfer of data from device A to device B unless the distance estimate at A is more than that at B at the previous iteration. For a line graph, [1] shows that monotonic filtering prevents quadratic overestimates. This paper analyzes monotonic filtering for an arbitrary graph topology, showing that for an N device network, the largest overestimate after switching sources is at most 2N.

cs.DC↗

arXiv2020

Field-based Coordination with the Share Operator

Field-based coordination has been proposed as a model for coordinating collective adaptive systems, promoting a view of distributed computations as functions manipulating data structures spread over space and evolving over time, called computational fields. The field calculus is a formal foundation for field computations, providing specific constructs for evolution (time) and neighbor interaction (space), which are handled by separate operators (called rep and nbr, respectively). This approach, however, intrinsically limits the speed of information propagation that can be achieved by their combined use. In this paper, we propose a new field-based coordination operator called share, which captures the space-time nature of field computations in a single operator that declaratively achieves: (i) observation of neighbors' values; (ii) reduction to a single local value; and (iii) update and converse sharing to neighbors of a local variable. We show that for an important class of self-stabilising computations, share can replace all occurrences of rep and nbr constructs. In addition to conceptual economy, use of the share operator also allows many prior field calculus algorithms to be greatly accelerated, which we validate empirically with simulations of frequently used network propagation and collection algorithms.

cs.DC↗

arXiv2019

On Distributed Runtime Verification by Aggregate Computing

Runtime verification is a computing analysis paradigm based on observing a system at runtime (to check its expected behaviour) by means of monitors generated from formal specifications. Distributed runtime verification is runtime verification in connection with distributed systems: it comprises both monitoring of distributed systems and using distributed systems for monitoring. Aggregate computing is a programming paradigm based on a reference computing machine that is the aggregate collection of devices that cooperatively carry out a computational process: the details of behaviour, position and number of devices are largely abstracted away, to be replaced with a space-filling computational environment. In this position paper we argue, by means of simple examples, that aggregate computing is particularly well suited for implementing distributed monitors. Our aim is to foster further research on how to generate aggregate computing monitors from suitable formal specifications.

cs.SE↗

arXiv2018

Aggregate Graph Statistics

Collecting statistic from graph-based data is an increasingly studied topic in the data mining community. We argue that these statistics have great value as well in dynamic IoT contexts: they can support complex computational activities involving distributed coordination and provision of situation recognition. We show that the HyperANF algorithm for calculating the neighbourhood function of vertices of a graph naturally allows for a fully distributed and asynchronous implementation, thanks to a mapping to the field calculus, a distribution model proposed for collective adaptive systems. This mapping gives evidence that the field calculus framework is well-suited to accommodate massively parallel computations over graphs. Furthermore, it provides a new "self-stabilising" building block which can be used in aggregate computing in several contexts, there including improved leader election or network vulnerabilities detection.

cs.DC↗

arXiv2018

Resilient Blocks for Summarising Distributed Data

Summarising distributed data is a central routine for parallel programming, lying at the core of widely used frameworks such as the map/reduce paradigm. In the IoT context it is even more crucial, being a privileged mean to allow long-range interactions: in fact, summarising is needed to avoid data explosion in each computational unit. We introduce a new algorithm for dynamic summarising of distributed data, weighted multi-path, improving over the state-of-the-art multi-path algorithm. We validate the new algorithm in an archetypal scenario, taking into account sources of volatility of many sorts and comparing it to other existing implementations. We thus show that weighted multi-path retains adequate accuracy even in high-variability scenarios where the other algorithms are diverging significantly from the correct values.

cs.DC↗

arXiv2017

Engineering Resilient Collective Adaptive Systems by Self-Stabilisation

Collective adaptive systems are an emerging class of networked computational systems, particularly suited in application domains such as smart cities, complex sensor networks, and the Internet of Things. These systems tend to feature large scale, heterogeneity of communication model (including opportunistic peer-to-peer wireless interaction), and require inherent self-adaptiveness properties to address unforeseen changes in operating conditions. In this context, it is extremely difficult (if not seemingly intractable) to engineer reusable pieces of distributed behaviour so as to make them provably correct and smoothly composable. Building on the field calculus, a computational model (and associated toolchain) capturing the notion of aggregate network-level computation, we address this problem with an engineering methodology coupling formal theory and computer simulation. On the one hand, functional properties are addressed by identifying the largest-to-date field calculus fragment generating self-stabilising behaviour, guaranteed to eventually attain a correct and stable final state despite any transient perturbation in state or topology, and including highly reusable building blocks for information spreading, aggregation, and time evolution. On the other hand, dynamical properties are addressed by simulation, empirically evaluating the different performances that can be obtained by switching between implementations of building blocks with provably equivalent functional properties. Overall, our methodology sheds light on how to identify core building blocks of collective behaviour, and how to select implementations that improve system performance while leaving overall system function and resiliency properties unchanged.

cs.DC↗

arXiv2017

Absoluteness via Resurrection

The resurrection axioms are forcing axioms introduced recently by Hamkins and Johnstone, developing on ideas of Chalons and Velicković. We introduce a stronger form of resurrection axioms (the \emph{iterated} resurrection axioms $\textrm{RA}_α(Γ)$ for a class of forcings $Γ$ and a given ordinal $α$), and show that $\textrm{RA}_ω(Γ)$ implies generic absoluteness for the first-order theory of $H_{γ^+}$ with respect to forcings in $Γ$ preserving the axiom, where $γ=γ_Γ$ is a cardinal which depends on $Γ$ ($γ_Γ=ω_1$ if $Γ$ is any among the classes of countably closed, proper, semiproper, stationary set preserving forcings). We also prove that the consistency strength of these axioms is below that of a Mahlo cardinal for most forcing classes, and below that of a stationary limit of supercompact cardinals for the class of stationary set preserving posets. Moreover we outline that simultaneous generic absoluteness for $H_{γ_0^+}$ with respect to $Γ_0$ and for $H_{γ_1^+}$ with respect to $Γ_1$ with $γ_0=γ_{Γ_0}\neqγ_{Γ_1}=γ_1$ is in principle possible, and we present several natural models of the Morse Kelley set theory where this phenomenon occurs (even for all $H_γ$ simultaneously). Finally, we compare the iterated resurrection axioms (and the generic absoluteness results we can draw from them) with a variety of other forcing axioms, and also with the generic absoluteness results by Woodin and the second author.

math.LO↗

arXiv2017

Generic Large Cardinals and Systems of Filters

We introduce the notion of $\mathcal{C}$-system of filters, generalizing the standard definitions of both extenders and towers of normal ideals. This provides a framework to develop the theory of extenders and towers in a more general and concise way. In this framework we investigate the topic of definability of generic large cardinals properties.

math.LO↗

arXiv2016

A Higher-order Calculus of Computational Fields

The complexity of large-scale distributed systems, particularly when deployed in physical space, calls for new mechanisms to address composability and reusability of collective adaptive behaviour. Computational fields have been proposed as an effective abstraction to fill the gap between the macro-level of such systems (specifying a system's collective behaviour) and the micro-level (individual devices' actions of computation and interaction to implement that collective specification), thereby providing a basis to better facilitate the engineering of collective APIs and complex systems at higher levels of abstraction. This paper proposes a full formal foundation for field computations, in terms of a core (higher-order) calculus of computational fields containing a few key syntactic constructs, and equipped with typing, denotational and operational semantics. Critically, this allows formal establishment of a link between the micro- and macro-levels of collective adaptive systems, by a result of full abstraction and adequacy for the (aggregate) denotational semantics with respect to the (per-device) operational semantics.

cs.LO↗

arXiv2014

An introduction to forcing axioms, SRP and OCA

These notes are extracted from the lectures on forcing axioms and applications held by professor Matteo Viale at the University of Turin in the academic year 2011-2012. Our purpose is to give a brief account on forcing axioms with a special focus on some consequences of them (SRP, OCA, PID). These principles were first isolated by Todor\v cević and interpolate most consequences of MM and PFA, thus providing a useful insight on the combinatorial structure of the theory of forcing axioms. In the first part of this notes we will give a brief account on forcing axioms, introducing some equivalent definition by means of generalized stationarity and presenting the consequences of them in terms of generic absoluteness. In the second part we will state the strong reflection principle (SRP), prove it under MM and examine its main consequences. This axiom is defined in terms of reflection properties of generalized stationary set. In the third part we will state the open coloring axiom (OCA), and provide consistency proofs for some versions of it. This axiom can be seen as a sort of two-dimensional perfect set property, i.e. the basic descriptive set theory result that every analytic set is either countable or it contains a perfect subset. In the last part we will explore a notable application of OCA to problems concerning properties of the continuum, in particular the existence of certain kind of gaps in $ω^ω$.

math.LO↗