Searcharxiv⌕ Search

arXiv subjects

Chryssis Georgiou

Publications and source records attributed to Chryssis Georgiou.

At least 19 recordsLinked to original sources
arXiv2026

On the Decidability of Distributed Tasks with Output Sets under Asynchrony and Any Number of Crashes

This paper studies the decidability of task problems, i.e., distributed problems expressed as sets of distributed tasks. Specifically, we introduce a new class of task problems called Set of Output Sets (SOS) problems. An SOS problem $\Pi_O$ is defined by a set $O$ (called SOS), and requires that the set of sets of distinct output values produced across all executions corresponds exactly to $O$. We then demonstrate that this class of problems is decidable: there is a procedure determining whether any SOS problem is solvable asynchronously under $f$ crashes. The decision rule is as follows. Every SOS problem is solvable when $f=0$. For $f > 0$, an SOS problem is solvable if and only if the graph $G=(O,\subset)$ is connected. In this graph, each vertex is an output set in $O$, and two vertices are linked by an edge whenever one output set includes the other. One of the surprising implications of our results is that, replacing validity by a completeness property (which guarantees that all output sets of size at most $k$ are produced), $k$-set agreement is solvable under any number of crashes $f \geq 0$ for $k>1$, and unsolvable under $f>0$ crashes only for $k=1$ (consensus). Finally, we study a novel family of problems called $d$-disagreement, which requires the system to always produce $d$ different output values, and we show that its implementability condition is related to the harmonic series.

cs.DC↗
arXiv2025

Tight Conditions for Binary-Output Tasks under Crashes

This paper explores necessary and sufficient system conditions to solve distributed tasks with binary outputs (\textit{i.e.}, tasks with output values in $\{0,1\}$). We focus on the distinct output sets of values a task can produce (intentionally disregarding validity and value multiplicity), considering that some processes may output no value. In a distributed system with $n$ processes, of which up to $t \leq n$ can crash, we provide a complete characterization of the tight conditions on $n$ and $t$ under which every class of tasks with binary outputs is solvable, for both synchronous and asynchronous systems. This output-set approach yields highly general results: it unifies multiple distributed computing problems, such as binary consensus and symmetry breaking, and it produces impossibility proofs that hold for stronger task formulations, including those that consider validity, account for value multiplicity, or move beyond binary outputs.

cs.DC↗
arXiv2025

From On-chain to Macro: Assessing the Importance of Data Source Diversity in Cryptocurrency Market Forecasting

This study investigates the impact of data source diversity on the performance of cryptocurrency forecasting models by integrating various data categories, including technical indicators, on-chain metrics, sentiment and interest metrics, traditional market indices, and macroeconomic indicators. We introduce the Crypto100 index, representing the top 100 cryptocurrencies by market capitalization, and propose a novel feature reduction algorithm to identify the most impactful and resilient features from diverse data sources. Our comprehensive experiments demonstrate that data source diversity significantly enhances the predictive performance of forecasting models across different time horizons. Key findings include the paramount importance of on-chain metrics for both short-term and long-term predictions, the growing relevance of traditional market indices and macroeconomic indicators for longer-term forecasts, and substantial improvements in model accuracy when diverse data sources are utilized. These insights help demystify the short-term and long-term driving factors of the cryptocurrency market and lay the groundwork for developing more accurate and resilient forecasting models.

q-fin.PM↗
arXiv2024

AMECOS: A Modular Event-based Framework for Concurrent Object Specification

In this work, we introduce a modular framework for specifying distributed systems that we call AMECOS. Specifically, our framework departs from the traditional use of sequential specification, which presents limitations both on the specification expressiveness and implementation efficiency of inherently concurrent objects, as documented by Casta\~neda, Rajsbaum and Raynal in CACM 2023. Our framework focuses on the interactions between the various system components, specified as concurrent objects. Interactions are described with sequences of object events. This provides a modular way of specifying distributed systems and separates legality (object semantics) from other issues, such as consistency. We demonstrate the usability of our framework by (i) specifying various well-known concurrent objects, such as registers, shared memory, message-passing, reliable broadcast, and consensus, (ii) providing hierarchies of ordering semantics (namely, consistency hierarchy, memory hierarchy, and reliable broadcast hierarchy), and (iii) presenting a novel axiomatic proof of the impossibility of the well-known Consensus problem.

cs.DC↗
arXiv2024

Ares II: Tracing the Flaws of a (Storage) God

Ares is a modular framework, designed to implement dynamic, reconfigurable, fault-tolerant, read/write and strongly consistent distributed shared memory objects. Recent enhancements of the framework have realized the efficient implementation of large objects, by introducing versioning and data striping techniques. In this work, we identify performance bottlenecks of the Ares's variants by utilizing distributed tracing, a popular technique for monitoring and profiling distributed systems. We then propose optimizations across all versions of Ares, aiming in overcoming the identified flaws, while preserving correctness. We refer to the optimized version of Ares as Ares II, which now features a piggyback mechanism, a garbage collection mechanism, and a batching reconfiguration technique for improving the performance and storage efficiency of the original Ares. We rigorously prove the correctness of Ares II, and we demonstrate the performance improvements by an experimental comparison (via distributed tracing) of the Ares II variants with their original counterparts.

cs.DC↗
arXiv2023

Self-stabilizing Byzantine-tolerant Recycling

Numerous distributed applications, such as cloud computing and distributed ledgers, necessitate the system to invoke asynchronous consensus objects an unbounded number of times, where the completion of one consensus instance is followed by the invocation of another. With only a constant number of objects available, object reuse becomes vital. We investigate the challenge of object recycling in the presence of Byzantine processes, which can deviate from the algorithm code in any manner. Our solution must also be self-stabilizing, as it is a powerful notion of fault tolerance. Self-stabilizing systems can recover automatically after the occurrence of arbitrary transient faults, in addition to tolerating communication and (Byzantine or crash) process failures, provided the algorithm code remains intact. We provide a recycling mechanism for asynchronous objects that enables their reuse once their task has ended, and all non-faulty processes have retrieved the decided values. This mechanism relies on synchrony assumptions and builds on a new self-stabilizing Byzantine-tolerant synchronous multivalued consensus algorithm, along with a novel composition of existing techniques.

cs.DC↗
arXiv2023

Loosely-self-stabilizing Byzantine-tolerant Binary Consensus for Signature-free Message-passing Systems

At PODC 2014, A. Mostéfaoui, H. Moumen, and M. Raynal presented a new and simple randomized signature-free binary consensus algorithm (denoted here MMR) that copes with the net effect of asynchrony Byzantine behaviors. Assuming message scheduling is fair and independent from random numbers MMR is optimal in several respects: it deals with up to t Byzantine processes where t < n/3 and n is the number of processes, O(n\^2) messages and O(1) expected time. The present article presents a non-trivial extension of MMR to an even more fault-prone context, namely, in addition to Byzantine processes, it considers also that the system can experience transient failures. To this end it considers self-stabilization techniques to cope with communication failures and arbitrary transient faults (such faults represent any violation of the assumptions according to which the system was designed to operate). The proposed algorithm is the first loosely-self-stabilizing Byzantine fault-tolerant binary consensus algorithm suited to asynchronous message-passing systems. This is achieved via an instructive transformation of MMR to a self-stabilizing solution that can violate safety requirements with probability Pr= O(1/(2M)), where M is a predefined constant that can be set to any positive integer at the cost of 3 M n + log M bits of local memory. In addition to making MMR resilient to transient faults, the obtained self-stabilizing algorithm preserves its properties of optimal resilience and termination, (i.e., t < n/3, and O(1) expected time). Furthermore, it only requires a bounded amount of memory.

cs.DC↗
arXiv2022

Validated Objects: Specification, Implementation, and Applications

Guaranteeing the validity of concurrent operations on distributed objects is a key property for ensuring reliability and consistency in distributed systems. Usually, the methods for validating these operations, if present, are wired in the object implementation. In this work, we formalize the notion of a {\em validated object}, decoupling the object operations and properties from the validation procedure. We consider two types of objects, satisfying different levels of consistency: the validated {\em totally-ordered} object, offering a total ordering of its operations, and its weaker variant, the validated {\em regular} object. We provide conditions under which it is possible to implement these objects. In particular, we show that crash-tolerant implementations of validated regular objects are always possible in an asynchronous system with a majority of correct processes. However, for validated totally-ordered objects, consensus is always required if a property of the object we introduce in this work, {\em persistent validity,} does not hold. Persistent validity combined with another new property, {\em persistent execution}, allows consensus-free crash-tolerant implementations of validated totally-ordered objects. We demonstrate the utility of validated objects by considering several applications conforming to our formalism.

cs.DC↗
arXiv2022

Fragmented ARES: Dynamic Storage for Large Objects

Data availability is one of the most important features in distributed storage systems, made possible by data replication. Nowadays data are generated rapidly and the goal to develop efficient, scalable and reliable storage systems has become one of the major challenges for high performance computing. In this work, we develop a dynamic, robust and strongly consistent distributed storage implementation suitable for handling large objects (such as files). We do so by integrating an Adaptive, Reconfigurable, Atomic Storage framework, called ARES, with a distributed file system, called COBFS, which relies on a block fragmentation technique to handle large objects. With the addition of ARES, we also enable the use of an erasure-coded algorithm to further split our data and to potentially improve storage efficiency at the replica servers and operation latency. To put the practicality of our outcomes at test, we conduct an in-depth experimental evaluation on the Emulab and AWS EC2 testbeds, illustrating the benefits of our approaches, as well as other interesting tradeoffs.

cs.DC↗
arXiv2021

Estimating Active Cases of COVID-19

Having accurate and timely data on confirmed active COVID-19 cases is challenging, since it depends on testing capacity and the availability of an appropriate infrastructure to perform tests and aggregate their results. In this paper, we propose methods to estimate the number of active cases of COVID-19 from the official data (of confirmed cases and fatalities) and from survey data. We show that the latter is a viable option in countries with reduced testing capacity or suboptimal infrastructures.

physics.soc-ph↗
arXiv2021

Byzantine-tolerant Distributed Grow-only Sets: Specification and Applications

In order to formalize Distributed Ledger Technologies and their interconnections, a recent line of research work has formulated the notion of Distributed Ledger Object (DLO), which is a concurrent object that maintains a totally ordered sequence of records, abstracting blockchains and distributed ledgers. Through DLO, the Atomic Appends problem, intended as the need of a primitive able to append multiple records to distinct ledgers in an atomic way, is studied as a basic interconnection problem among ledgers. In this work, we propose the Distributed Grow-only Set object (DSO), which instead of maintaining a sequence of records, as in a DLO, maintains a set of records in an immutable way: only Add and Get operations are provided. This object is inspired by the Grow-only Set (G-Set) data type which is part of the Conflict-free Replicated Data Types. We formally specify the object and we provide a consensus-free Byzantine-tolerant implementation that guarantees eventual consistency. We then use our Byzantine-tolerant DSO (BDSO) implementation to provide consensus-free algorithmic solutions to the Atomic Appends and Atomic Adds (the analogous problem of atomic appends applied on G-Sets) problems, as well as to construct consensus-free Single-Writer BDLOs. We believe that the BDSO has applications beyond the above-mentioned problems.

cs.DC↗
arXiv2021

Fragmented Objects: Boosting Concurrency of Shared Large Objects

This work examines strategies to handle large shared data objects in distributed storage systems (DSS), while boosting the number of concurrent accesses, maintaining strong consistency guarantees, and ensuring good operation performance. To this respect, we define the notion of fragmented objects:con-current objects composed of a list of fragments (or blocks) that allow operations to manipulate each of their fragments individually. As the fragments belong to the same object, it is not enough that each fragment is linearizable to have useful consistency guarantees in the composed object. Hence, we capture the consistency semantic of the whole object with the notion of fragmented linearizability. Then, considering that a variance of linearizability, coverability, is more suited for versioned objects like files, we provide an implementation of a distributed file system, called COBFS, that utilizes coverable fragmented objects (i.e., files).In COBFS, each file is a linked-list of coverable block objects. Preliminary emulation of COBFS demonstrates the potential of our approach in boosting the concurrency of strongly consistent large objects.

cs.DC↗
arXiv2020

A Self-stabilizing Control Plane for the Edge and Fog Ecosystems

Fog Computing is now emerging as the dominating paradigm bridging the compute and connectivity gap between sensing devices (a.k.a. "things") and latency-sensitive services. However, as fog deployments scale by accumulating numerous devices interconnected over highly dynamic and volatile network fabrics, the need for self-configuration and self-healing in the presence of failures is more evident now than ever. Using the prevailing methodology of self-stabilization, we propose a fault-tolerant framework for distributed control planes that enables fog services to cope and recover from a very broad fault model. Specifically, our model considers network uncertainties, packet drops, node fail-stop failures, and violations of the assumptions according to which the system was designed to operate, such as an arbitrary corruption of the system state. Our self-stabilizing algorithms guarantee automatic recovery within a constant number of communication rounds without the need for external (human) intervention. To showcase the framework's effectiveness, the correctness proof of the proposed self-stabilizing algorithmic process is accompanied by a comprehensive evaluation featuring an open and reproducible testbed utilizing real-world data from the intelligent transportation domain. Results show that our framework ensures a fog ecosystem recovery from faults in constant time, analytics are computed correctly, while the overhead to the system's control plane scales linearly towards the IoT load.

cs.DC↗
arXiv2020

(In)Existence of Equilibria for 2-Players, 2-Values Games with Concave Valuations

We consider 2-players, 2-values minimization games where the players' costs take on two values, $a,b$, $a b$, then there exists a normal 2-players, 2-values, 3-strategies game without $\mathsf{F}$-equilibrium. To the best of our knowledge, this work is the first to provide an (almost complete) answer on whether there is, for a given concave function $\mathsf{F}$, a counterexample game without $\mathsf{F}$-equilibrium.

cs.GT↗
arXiv2020

CoronaSurveys: Using Surveys with Indirect Reporting to Estimate the Incidence and Evolution of Epidemics

The world is suffering from a pandemic called COVID-19, caused by the SARS-CoV-2 virus. National governments have problems evaluating the reach of the epidemic, due to having limited resources and tests at their disposal. This problem is especially acute in low and middle-income countries (LMICs). Hence, any simple, cheap and flexible means of evaluating the incidence and evolution of the epidemic in a given country with a reasonable level of accuracy is useful. In this paper, we propose a technique based on (anonymous) surveys in which participants report on the health status of their contacts. This indirect reporting technique, known in the literature as network scale-up method, preserves the privacy of the participants and their contacts, and collects information from a larger fraction of the population (as compared to individual surveys). This technique has been deployed in the CoronaSurveys project, which has been collecting reports for the COVID-19 pandemic for more than two months. Results obtained by CoronaSurveys show the power and flexibility of the approach, suggesting that it could be an inexpensive and powerful tool for LMICs.

cs.DC↗
arXiv2020

Self-Stabilizing Snapshot Objects for Asynchronous Fail-Prone Network Systems

A snapshot object simulates the behavior of an array of single-writer/multi-reader shared registers that can be read atomically. Delporte-Gallet et al. proposed two fault-tolerant algorithms for snapshot objects in asynchronous crash-prone message-passing systems. Their first algorithm is \emph{non-blocking}; it allows snapshot operations to terminate once all write operations have ceased. It uses $O(n)$ messages of $O(n ν)$ bits, where $n$ is the number of nodes and $ν$ is the number of bits it takes to represent the object. Their second algorithm allows snapshot operations to always terminate independently of write operations. It incurs $O(n^2)$ messages. The fault model of Delporte-Gallet et al. considers node crashes. We aim at the design of even more robust snapshot objects via the lenses of self-stabilization---a very strong notion of fault-tolerance. In addition to Delporte-Gallet et al.'s fault model, our self-stabilizing algorithm can recover after the occurrence of transient faults; these faults represent arbitrary violations of the assumptions according to which the system was designed to operate. We propose self-stabilizing variations of Delporte-Gallet et al.'s non-blocking algorithm and always-terminating algorithm. Our algorithms have similar communication costs to the ones by Delporte-Gallet et al. and $O(1)$ recovery time from transient faults. The main differences are that our proposal considers repeated gossiping of $O(ν)$ bit messages and deals with bounded space. We also consider an input parameter, $δ$, for which we claim an ability to balance the costs of snapshot operations. We validate our correctness proof, evaluate the performance of Delporte-Gallet et al.'s algorithms and our proposed variations and investigate the properties of $δ$ via PlanetLab experiments, where significant latency and communication costs reduction are observed.

cs.DC↗
arXiv2020

Appending Atomically in Byzantine Distributed Ledgers

A Distributed Ledger Object (DLO) is a concurrent object that maintains a totally ordered sequence of records, and supports two basic operations: append, which appends a record at the end of the sequence, and get, which returns the sequence of records. In this work we provide a proper formalization of a Byzantine-tolerant Distributed Ledger Object (BDLO), which is a DLO in a distributed system in which processes may deviate arbitrarily from their indented behavior, i.e. they may be Byzantine. Our formal definition is accompanied by algorithms to implement BDLOs by utilizing an underlying Byzantine Atomic Broadcast service. We then utilize the BDLO implementations to solve the Atomic Appends problem against Byzantine processes. The Atomic Appends problem emerges when several clients have records to append, the record of each client has to be appended to a different BDLO, and it must be guaranteed that either all records are appended or none. We present distributed algorithms implementing solutions for the Atomic Appends problem when the clients (which are involved in the appends) and the servers (which maintain the BDLOs) may be Byzantine.

cs.DC↗