CycleSync: Cycle-Based Synchronization

• CycleSync is a concept employing cycle-aware structures to achieve synchronization in heterogeneous systems, from IoT networks to multimedia evaluation.
• It includes protocols like C-sync that use clustering and local consensus to lower power use, reduce message overhead, and enhance fault resilience in resource-constrained environments.
• CycleSync also serves as a video-to-audio synchronization metric that leverages cycle-consistency for robust audio event recovery and improved alignment with human judgments.

Searching arXiv for papers using the term "CycleSync" and closely related synchronization work. CycleSync denotes a family of cycle-structured synchronization constructs rather than a single universally standardized object. In recent literature, the term appears most explicitly in two forms: C-sync, a clustering-based decentralized network time synchronization protocol for large-scale, resource-constrained IoT systems, and CycleSync, a video-to-audio-based metric for evaluating fine-grained audio-video synchronization. The current literature suggests that the unifying idea is the use of cycles—network timing cycles, graph cycles, or cycle-consistency loops—as the primary mathematical or algorithmic object for synchronization, robustness, or evaluation (Shivaraman et al., 2024, Song et al., 26 Sep 2025).

1. Terminological scope

Usage	Definition in the literature	Representative source
C-sync	A clustering-based decentralized time synchronization protocol for IoT networks	(Shivaraman et al., 2024)
CycleSync	A video-to-audio-based metric that measures the amount of motion cues in the generated video to reconstruct the original audio	(Song et al., 26 Sep 2025)
Cycle-based synchronization analysis	Use of circulation, cycle consistency, or long consistent cycles to characterize synchronized or robust behavior	(Ge et al., 2009, Lerman et al., 2019, Li et al., 2024)

The current literature suggests that the label is best understood as a domain-dependent designation for synchronization through cyclic structure. In IoT timing, the cycle is the communication and clock-update cycle. In audio-video evaluation, the cycle is a reconstruction loop from video back to audio. In stochastic dynamics and group synchronization, cycles are directed loops in a Markov chain or measurement graph whose consistency properties reveal order, corruption, or nonequilibrium structure.

A common misconception is to treat CycleSync as a single protocol family with a fixed algorithmic core. The published record does not support that interpretation. Instead, it supports a broader view in which cycle-aware representations provide either the synchronization mechanism itself, the diagnostic signal for synchronization quality, or the combinatorial substrate for robust inference.

2. C-sync as a decentralized IoT time-synchronization protocol

C-sync is a decentralized, cluster-based network time synchronization protocol designed for large-scale, resource-constrained IoT networks. It addresses two limitations identified in prior work: the common assumption that all nodes are faultless, and the communication and energy overhead induced by exchanging a large number of messages. Its scalability is achieved by introducing multiple reference nodes in the network that restrict the maximum number of hops any node can have to its time source, and its software design is modular on the Contiki platform to allow application transitions (Shivaraman et al., 2024).

The network is partitioned into clusters using the DeCoRIC clustering scheme. Each node assumes one of three roles: Cluster Head (CH), Cluster Bridge (CB), or Common Member (CM). CHs serve as local synchronizers and communication focal points; CBs connect CHs and support inter-cluster synchronization and redundancy; CMs are regular nodes that remain mostly in low-power sleep mode except when updating their clocks. Within clusters, certain CHs with the most CH neighbors are nominated as Local Centers (LCs), which act as local time reference nodes and bound synchronization depth.

C-sync proceeds through a seven-state machine: Discovery, Election Revelation, Election Declaration, Connection Revelation, Connection Declaration, Consensus Convergence, and Consensus Synchronization. After clustering, only CHs and CBs actively communicate, whereas CMs only listen and then sleep. This role asymmetry is central to the protocol’s energy model: active communication is concentrated in a small subset of the topology, while the majority of nodes remain quiescent for most of the duty cycle.

Architecturally, C-sync is a cluster-restricted alternative to flat decentralized synchronization. It does not require every node to participate equally in every synchronization round. The protocol instead localizes synchronization, reference dissemination, and fault handling to cluster scopes and bridge paths.

3. Fault model, consensus machinery, and mathematical formulation

C-sync explicitly handles four fault classes: fail-stop (crash/energy exhaustion), selective forwarding, Byzantine subset (spikes, outliers), and intermittent communication. Faulty nodes are neutralized using in-cluster Byzantine consensus via so-called atomic broadcasts. If a node, especially a CH or CB, is non-responsive or provides erroneous data, CB nodes initiate consensus to validate time information. Authentication uses AES encryption over 802.15.4 security, with a composite key from CH IDs to prevent spoofing or fake CBs (Shivaraman et al., 2024).

The protocol assumes that nodes cannot fake hardware MAC addresses; that each node has at least $\left\lfloor \frac{n_i}{2} + 1 \right\rfloor$ correct neighbors; and that between any cluster pair there are at least $\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$ correct CBs and no partition. Under these assumptions, the summarized theorem states that any arbitrary pattern of up to $k < \frac{n_i}{2}$ faulty nodes per cluster and $k < \frac{n_{CB}}{2}$ faulty CBs can be detected and corrected.

Each node $i$ maintains a logical clock

$$L_i(t) = \int_0^t h_i(\tau) l_i(\tau) \, d\tau + \theta_i(t),$$

where $h_i(\tau)$ is the hardware clock, $l_i(\tau)$ is the logical clock rate relative to the hardware clock, and $\theta_i(t)$ is the logical clock offset. The update rules are

$$l_i(t+1) = \frac{\sum_{j \in n_i} l_j(t) + l_i(t)}{n_i + 1},$$

and

$\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$0

This neighbor-averaging is described as providing resilience against outliers, specifically single faulty clocks.

The maximum cumulative synchronization error for a node at $\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$1 hops from its LC is

$\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$2

where $\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$3 is the maximum number of hops to the LC, $\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$4 is the idle time between model updates, and $\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$5 is the minimum achievable synchronization error. To compensate for DCO drift, the protocol uses

$\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$6

with expected timer-B ticks $\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$7 and actual timer-B ticks $\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$8, and corrects the hardware clock value as $\left\lfloor \frac{n_{CB}}{2} + 1 \right\rfloor$9.

4. Implementation and empirical evaluation of C-sync

C-sync is implemented on Contiki OS 3.0 using Tmote Sky motes with an MSP430 MCU, CC2420 radio, and IEEE 802.15.4. It runs as an independent module that can be invoked by applications needing synchronization, exposes an idle phase for resource sharing with application layers, and uses the Rime stack for efficient message passing with broadcast suppression. The evaluation uses a real deployment of more than 40 Tmote Sky nodes distributed across different levels in a building, specifically the Indriya Testbed, and compares C-sync qualitatively with state-of-the-art protocols and quantitatively with a class of decentralized protocols derived from GTSP (Shivaraman et al., 2024).

Topology	GTSP: Sync Error / Power	C-sync: Sync Error / Power
Dense	7.05 $k < \frac{n_i}{2}$0 / 0.98 $k < \frac{n_i}{2}$1 mW	7.52 $k < \frac{n_i}{2}$2 / 0.43 $k < \frac{n_i}{2}$3 mW
Sparse	7.67 $k < \frac{n_i}{2}$4 / 1.98 $k < \frac{n_i}{2}$5 mW	10.05 $k < \frac{n_i}{2}$6 / 0.48 $k < \frac{n_i}{2}$7 mW
Full-net (All nodes)	10.13 $k < \frac{n_i}{2}$8 / 0.89 $k < \frac{n_i}{2}$9 mW	12.24 $k < \frac{n_{CB}}{2}$0 / 0.43 $k < \frac{n_{CB}}{2}$1 mW

The protocol is reported to detect and isolate faults to a cluster and to recover quickly. The abstract reports a reduction of 56.12% and 75.75% in power consumption in the worst-case and best-case scenarios, respectively, compared to GTSP, while achieving similar accuracy. The detailed evaluation further states that faults injected into CH nodes are quickly detected and isolated within a single cluster, that network-wide synchronization remains unaffected, and that the error remains bounded by the maximum hops to the LC, with measured $k < \frac{n_{CB}}{2}$2 over 5 hops.

These results position C-sync as a cluster-restricted, fault-aware alternative to flat decentralized protocols. Its performance profile is not defined by maximal absolute accuracy alone; it is defined by the joint objective of similar accuracy, lower power, local fault containment, and bounded synchronization depth.

5. CycleSync as an audio-video synchronization metric

In the Syncphony framework, CycleSync is introduced as a video-to-audio-based metric for evaluating synchronization in audio-to-video generation. Rather than comparing audio and visual streams directly, it uses a cycle-consistency formulation: the generated video $k < \frac{n_{CB}}{2}$3 is passed through a pretrained video-to-audio model $k < \frac{n_{CB}}{2}$4 to reconstruct audio $k < \frac{n_{CB}}{2}$5,

$k < \frac{n_{CB}}{2}$6

and synchronization is measured by comparing onset peaks in the original audio and the reconstructed audio. The metric is motivated by limitations in prior metrics such as RelSync, AlignSync, and AV-Align, which may require downsampling and may assume overly rigid peak-to-peak temporal matching (Song et al., 26 Sep 2025).

Let $k < \frac{n_{CB}}{2}$7 and $k < \frac{n_{CB}}{2}$8 denote onset peaks extracted from the original and reconstructed audio. CycleSync is defined as

$k < \frac{n_{CB}}{2}$9

Implementation details specify the use of the pretrained V2A model V-AURA and librosa’s onset.onset_detect.

The metric is intended to be tolerant to realistic temporal structure. The motivating example in the paper notes that a hammer may move before the impact sound and stop at the sound, so strict peak-to-peak alignment is not always appropriate. CycleSync therefore treats synchronization as recoverability of audio event structure from video motion cues rather than as literal framewise coincidence between motion extrema and acoustic peaks.

Empirically, CycleSync is reported on AVSync15 and The Greatest Hits. On AVSync15, the reported scores are 16.48 ± 1.28 for the method labeled “Ours,” 16.38 ± 1.38 for AVSyncD, and 22.15 ± 1.8 for ground truth. On The Greatest Hits, the reported value for “Ours” is 16.18 ± 1.26, exceeding the reported ground-truth value 15.99 ± 1.5; the paper attributes this to generated videos being more motion-focused than real ones. The metric is also reported to drop more sharply than prior metrics under artificial time shifts, and its Pearson correlation with human judgments of synchronization is 0.486, compared with 0.043 for AV-Align and negative correlations for RelSync and AlignSync. A known limitation is that accuracy depends on the capabilities and domain coverage of the underlying V2A model.

6. Related cycle-centric synchronization theories and methods

CycleSync-like reasoning has close antecedents in stochastic dynamics. In a stochastic Boolean network model of the yeast cell cycle, circulation theory of Markov chains is used to show that synchronized stochastic dynamics can be characterized by a dominant circulation. In that setting, the dominant main cycle is described as the natural generalization of the deterministic limit cycle, and the period of the main peak in the power spectrum is reported to correspond exactly to the number of states in the main cycle, namely 13. The underlying phenomenon is a nonequilibrium steady state with a large separation in circulation magnitude between one dominant cycle and the rest (Ge et al., 2009).

In oscillator synchronization, cycle structure appears as repeated firing and aggregation. For identical pulse-coupled oscillators with global interactions, synchronization can be formulated as cluster kinetics, with the disorder parameter obeying laws such as $i$0 in the original scrambler model and a piecewise linear form

$i$1

for the firefly model on intervals $i$2. In duty-cycled IoT networks, the EBS scheme models nodes as pulse-coupled oscillators with phase advancement

$i$3

and $i$4, with synchronization error tolerance windows $i$5, synchronicity

$i$6

and convergence conditions including

$i$7

Reported test-bed results on Motelab and MicaZ show $i$8 broadcast throughput with average duty-cycle below $i$9 for $$L_i(t) = \int_0^t h_i(\tau) l_i(\tau) \, d\tau + \theta_i(t),$$0 (O'Keeffe et al., 2015, Yadav et al., 2017).

A separate pulse-coupled oscillator line addresses clock continuity. Two general methods—constant frequency and constant time—replace jump updates by continuous phase evolution. Their adjustment rules use

$$L_i(t) = \int_0^t h_i(\tau) l_i(\tau) \, d\tau + \theta_i(t),$$1

and induce an effective coupling

$$L_i(t) = \int_0^t h_i(\tau) l_i(\tau) \, d\tau + \theta_i(t),$$2

The published analysis shows that synchronization is preserved under these continuous-update methods, at the cost of some reduction in convergence speed (Anglea et al., 2017).

In graph-based synchronization, cycle consistency becomes a robustness criterion. The Cycle-Edge Message Passing framework initializes edge corruption scores via

$$L_i(t) = \int_0^t h_i(\tau) l_i(\tau) \, d\tau + \theta_i(t),$$3

and iteratively updates them using cycle weights such as $$L_i(t) = \int_0^t h_i(\tau) l_i(\tau) \, d\tau + \theta_i(t),$$4, with exact recovery and linear convergence guarantees under bounded local cycle corruption. Long-cycle methods extend this logic beyond triangles: an algorithm using cycles of lengths three to six achieves time complexity of order $$L_i(t) = \int_0^t h_i(\tau) l_i(\tau) \, d\tau + \theta_i(t),$$5, or $$L_i(t) = \int_0^t h_i(\tau) l_i(\tau) \, d\tau + \theta_i(t),$$6 with faster matrix multiplication, and is motivated in part by distributed synchronization settings in which 3-cycles are unavailable and at least 4-cycles are required (Lerman et al., 2019, Li et al., 2024).

A plausible implication is that CycleSync, across these literatures, names not a single technique but a methodological orientation. Whether the object is a logical clock, an oscillator phase, a graph edge, or an audio event sequence, the defining move is to make cyclic structure operational: as a state trajectory in a Markov chain, as a bounded-hop synchronization loop in a cluster, as a cycle-consistency constraint in a measurement graph, or as a reconstruction loop for cross-modal evaluation.