1

# Decentralized Learning Made Easy with DecentralizePy

Akash Dhasade  EPFL 0000-0003-4362-5548 ,  Anne-Marie Kermarrec
0000-0001-8187-724X EPFL ,  Rafael Pires  0000-0002-7826-1599 EPFL ,  Rishi
Sharma  0000-0002-1928-1549 EPFL and  Milos Vujasinovic  EPFL
0009-0006-5083-3045

(2023)

###### Abstract.

DL has gained prominence for its potential benefits in terms of scalability,
privacy, and fault tolerance. It consists of many nodes that coordinate
without a central server and exchange millions of parameters in the inherently
iterative process of machine learning (ML) training. In addition, these nodes
are connected in complex and potentially dynamic topologies. Assessing the
intricate dynamics of such networks is clearly not an easy task. Often in
literature, researchers resort to simulated environments that do not scale and
fail to capture practical and crucial behaviors, including the ones associated
to parallelism, data transfer, network delays, and wall-clock time. In this
paper, we propose decentralizepy, a distributed framework for decentralized
ML, which allows for the emulation of large-scale learning networks in
arbitrary topologies. We demonstrate the capabilities of decentralizepy by
deploying techniques such as sparsification and secure aggregation on top of
several topologies, including dynamic networks with more than one thousand
nodes.

decentralized learning, middleware, machine learning, distributed systems,
peer-to-peer, network topology

††conference: 3rd Workshop on Machine Learning and Systems; May 8, 2023; Rome,
Italy††journalyear: 2023††copyright: acmlicensed††booktitle: 3rd Workshop on
Machine Learning and Systems (EuroMLSys ’23), May 8, 2023, Rome, Italy††price:
15.00††isbn: 979-8-4007-0084-2/23/05††doi: 10.1145/3578356.3592587††ccs:
Networks Programming interfaces††ccs: Computing methodologies Distributed
algorithms††ccs: Computing methodologies Machine learning algorithms††ccs:
Computer systems organization Peer-to-peer architectures

##  1\. Introduction

There has been a shift in ML training, which is now taking place at the
location where data is generated, instead of the earlier method of first
moving the data to be processed in data centers. FL (McMahan et al., 2017) and
decentralized learning (DL) (Lian et al., 2017) have become prominent
collaborative training methods that prioritize privacy, by solely exchanging
updates of the model being trained. In federated learning (FL), training is
orchestrated by a central server where the server broadcasts the global model
to participating nodes and later aggregates the updates received back from
them. Conversely, in DL, nodes are connected in a fully decentralized
communication topology. Rather than relying on a server, nodes in DL train on
their local datasets and share the resulting models with neighboring nodes.
The aggregated models obtained from these exchanges lead to a converged global
model at the end of the DL training process. While FL has already received
more attention from academia and industry (Yang et al., 2018; Bonawitz et al.,
2019; Caldas et al., 2019; Kairouz et al., 2020), DL is also recently gaining
a lot of traction (Lian et al., 2017; Koloskova et al., 2020b, 2019, a).

The popularity of FL has been partially enabled by the availability of several
frameworks for simulation or emulation (Abadi et al., 2016; Ziller et al.,
2021; He et al., 2020; Liu et al., 2021; Beutel et al., 2020; Lai et al.,
2022; Roth et al., 2022), which allow researchers to quickly implement and
assess novel FL algorithms. Support for DL configurations, on the other hand,
is rare and limited in these existing frameworks (He et al., 2020). FL
frameworks typically offer abstractions for client-server interactions which
are not suitable for DL, since nodes in DL communicate only with their
immediate neighbors. These limitations call for frameworks that provide
abstractions involving peer-to-peer communication channels and topology
manipulation for collaborative ML training.

DL research has often focused on exploring the impact of topology on learning
performance (Bellet et al., 2022; Vogels et al., 2022), which has led to
simulations using various static and dynamic topologies during training
(Koloskova et al., 2020b). Another important area of DL research targets to
improve communication efficiency through compression, which reduces the number
of model parameters exchanged between DL nodes (Strom, 2015; Alistarh et al.,
2018; Lin et al., 2018). This includes techniques such as sparsification
(Alistarh et al., 2018) and quantization (Alistarh et al., 2017), which are
either not readily available in FL frameworks, or incompatible with DL. The
same happens in secure aggregation (Bonawitz et al., 2017), which imposes
additional challenges when deployed in DL training. decentralizepy offers
these capabilities, empowering researchers to explore and innovate on DL
research without being constrained by the limitations of existing FL
frameworks.

Although we are not exhaustive in implementing all aspects of DL systems, we
provide, along with reference implementations, a modular and extensible
framework that aims at easing the prototyping and deployment of such systems.
We demonstrate this flexibility with various topologies, sparsification, and
secure aggregation techniques in DL training. Our results provide insights to
encourage more research on these areas in order to improve the practicality of
DL.

#### Contributions

  * •

We present decentralizepy, a novel decentralized learning framework, which
allows researchers and practitioners to experiment with the components of DL
systems and deploy them in real-world settings.

  * •

We showcase how decentralizepy can be leveraged to assess the effects of
several topologies, dynamic networks, sparsification techniques, and secure
aggregation in DL systems.

  * •

decentralizepy is modular, easily extendable, and open-source (Sharma et al.,
2022) under MIT License.

The remainder of this paper is organized as follows: Section 2 describes the
framework internals and Section 3 showcases its usage in several scenarios. We
survey related work in Section 4 and conclude in Section 5.

##  2\. DecentralizePy

Figure 1. Overview of the decentralizepy framework. Each node along with its
driver may run on a separate machine. The driver takes as input the
specifications and modules. The node dynamically loads the specified modules.
Results are dumped locally and later aggregated. Nodes can be specialized to
perform different tasks. In conventional DL, we would have only basic Node(s).
To emulate FL, a node can be modified to coordinate the training, shown as the
FL server.

###  2.1. Design overview

Works in DL research are mostly evaluated in simulated environments. These
simulations are either done in scenarios where a single machine simulates all
nodes (, not scalable), or in cluster settings over MPI (, constrained to the
local area network (LAN)) (Bellet et al., 2022; Vogels et al., 2022; Zhu et
al., 2022; Vogels et al., 2020). The design of decentralizepy takes into
account two key needs: the ability to quickly develop research prototypes, as
well as actually deploying large-scale DL systems. We elaborate next on these
design goals.

#### Modularity.

DL systems consist of multiple components, and conducting research in this
field requires adjusting and testing them. For generality, it is often
necessary to evaluate different datasets and models when building learning
systems. In decentralized training, the overlay topology, the way nodes are
connected, is especially critical for achieving satisfactory model convergence
(Bars et al., 2023). Finally, the protocol itself, who to communicate with,
what is the message content, and how to aggregate the received parameters,
varies among systems. To facilitate the implementation of new DL systems and
experimentation with various ML aspects, including datasets, models, and
topologies, decentralizepy incorporates loosely coupled modules with an
object-oriented design. Section 2.2 provides a more detailed explanation of
these modules.

#### One-node one-process.

In order to achieve rapid prototyping, researchers commonly favor simple
implementations built from scratch. In DL systems, this often means
simulations on a single machine or in a cluster environment (Bellet et al.,
2022; Vogels et al., 2022; Zhu et al., 2022; Vogels et al., 2020). Real-world
deployment of such systems would however imply numerous nodes running on
geographically-distant machines. Unfortunately, DL systems specifically
designed for cluster environments are difficult to configure and scale beyond
the LAN. decentralizepy has a one-node as one-process design principle, so
that we are able to scale and measure realistic system metrics at the
granularity of a node (or process). In other words, one DL node is represented
as a single process. These nodes communicate over network sockets and do not
distinguish processes on the same or different machines. This means that the
same testbed can run in a cluster environment or on real-world machines over
wide area networks by just configuring the IP address information. This
approach simplifies the configuration of system parameters like the number of
processes per node (according to, for instance, the number of CPU cores),
network bandwidth, latency, and packet drop, enabling practitioners to study
their systems in detail. In addition, measurements of system metrics such as
data transferred, memory usage, and CPU time become easier to collect on each
node. Furthermore, the emulation and deployment can reveal behaviors that
would not show up in simulations. These benefits streamline the assessment of
the performance and scalability of DL systems.

###  2.2. Architecture

In this section, we describe decentralizepy modules and how they can be
customized to develop new DL systems. Figure 1 shows the architecture of the
framework and how different modules are integrated.

#### Node.

The node module acts as the skeleton code that performs the DL task by
instantiating and calling the methods of the rest of the modules. An object of
a sub-class of the node module is instantiated when a DL process starts. A
node can be designed to perform a variety of tasks from being a DL client to a
FL server or a centralized peer sampler. The node module provides complete
flexibility in creating and decoding messages to be exchanged with peers. To
get practitioners started with decentralizepy, the framework is already
equipped with the implementations of DL clients, a centralized peer sampler, a
parameter server, a FL server, and secure aggregation clients as nodes.

#### Graph.

The graph module manages the overlay network, which constrains the
communication of nodes to only immediate neighbors. This overlay graph can be
modified at run time by the node, hence supporting both static and dynamic
topologies. The topology can be read from a graph file having edges or an
adjacency list. With this, we support swift switching of topologies, which
could be generated by external libraries, during experimentation. A graph file
specifying the topology is shown as the _topology specification_ in Figure 1.

#### Model.

This is a lightweight module inheriting the model class of the underlying ML
framework. The main purpose of having a model module is to store additional
states. For instance, this module allows the developer to store past gradients
or how much the learning parameters changed in the last iteration. This is
especially convenient for some sparsification algorithms. Since the models are
quite specific to the datasets, these are implemented as part of the dataset
modules.

#### Dataset.

ML frameworks must support a diverse range of datasets and models. The dataset
module of our framework provides this for a variety of learning tasks over
multiple datasets and models, seamlessly integrating with the other modules.
Among the tasks it performs, we highlight: _(i)_ reading the train and test
sets; _(ii)_ partitioning the datasets among nodes; _(iii)_ evaluating the
performance of a trained model on the test set; and _(iv)_ specific model
implementations. decentralizepy includes six datasets from the LEAF FL
benchmark (Caldas et al., 2019) and CIFAR-10 (Krizhevsky et al., 2014) with
both independent and identically distributed (IID) and non independent and
identically distributed (non-IID) data partitioning.

#### Training.

The training module performs local training steps of the model on the given
training set. The optimizer and loss function for the learning tasks are
provided as part of the training specifications shown in Figure 1. Having
access to the instances of both model and dataset modules, the training module
can modify the additional state variables in these modules for various
purposes, prioritizing certain weights during model compression.

#### Sharing and Communication

In DL, the nodes interact by exchanging messages. The sharing module decides
the contents of these messages and the aggregation procedure. For model
sharing, the messages would contain serialized parameters and the aggregation
scheme will average the received models. In the presence of sparsification
(model compression), the messages would contain a subset of model parameters,
and the aggregation scheme needs to account for missing parameters.
Implementations of sparsification schemes such as random sampling, TopK
(Alistarh et al., 2018), and Choco-SGD (Koloskova et al., 2019) are available
as sharing modules in decentralizepy. For data-sharing architectures (Dhasade
et al., 2022), in turn, the sharing module would include raw data in the
messages, and the aggregation procedure would append the received data to the
local dataset. These messages are passed on to communication by the node to
send them to the correct recipients. decentralizepy also has an existing
implementation of communication using ZeroMQ (Boccassi et al., 2023) over TCP.

⬇

1from decentralizepy.node.Node import Node

2

3class DLNode(Node):

4 def run(self, iterations, training, dataset, sharing, graph, communication):

5 for round in range(iterations):

6 training.train(dataset)

7 msg = sharing.get_message()

8 neighbors = graph.get_neighbors()

9 communication.send(neighbors, msg)

10 rcv = communication.receive_from_all()

11 sharing.average(rcv)

12 dataset.test()

Figure 2. A Python code snippet to demonstrate a simple DL node using the
modules of decentralizepy colored in red. The node repeatedly trains its model
on the local dataset (line 6), exchanges the model with the neighbors (lines
7-10), aggregates the models (line 11), and evaluates the average model on the
test set (line 12). Figure 3. Performance of 256-node DL across three
topologies and a dynamic 5-regular graph. _(a)_ The denser the topology, the
better the accuracy: fully connected ¿ d-regular ¿ ring. They all run for the
same number of communication rounds. _(b)_ When considering emulation time,
fully connected takes the longest to perform the same number of rounds. _(c)_
Denser topologies incur significantly more communication costs. We observe
that d-regular graphs offer a favorable tradeoff between accuracy,
communication, and emulation time compared to _ring_ or _fully connected_.
Dynamic d-regular surprisingly matches the convergence of fully connected
across time (b) at significantly lower communication cost (c).

#### Mapping, Compression, and Utils

There are some auxiliary modules to support the framework: (1) Mapping, (2)
compression, and (3) utils. To support both cluster environments and real-
world deployment, mapping associates nodes with particular machines.
Compression module packages general-purpose compression algorithms for
floating-point and integer lists. Utils contains commonly used functions
across the framework like Python dictionary manipulations and command-line
argument parsing.

decentralizepy allows the developer to instantiate a node and provide the
implementations of the other modules separately, as shown in Figure 1. Each
module provides a base class that defines the interface for the module. New
implementations of modules can extend the base class and legacy
implementations may be ported by wrapping them in the module interface. These
implementations are dynamically loaded to streamline the process of
substituting the implementations for rapid prototyping. Furthermore, since
decentralizepy is fully-decentralized, the nodes can have heterogenous
datasets, different sharing strategies, optimizers, and learning rates for
full flexibility. Figure 2 shows how to write a simplified decentralized
learning node using decentralizepy. The functions of the other modules
(sharing) invoked here can be overloaded to customize the system. Given the
decentralized nature of the nodes, each of them locally writes logs and
results in JSON files. To compute aggregate statistics of the system, we
collect and process the results in a single machine at the end.

###  2.3. Implementation

Written in Python v3.8, the modules span a total of over $10\,000$ lines of
code. Additionally, the framework inherits core ML functionalities from
PyTorch v1.10.2 (Paszke et al., 2019). decentralizepy contains several
implementations of modules to facilitate building DL systems as described
earlier. It is important to note that these are just reference implementations
for a quick start in developing new DL systems with the framework. We call for
the support of the scientific community to improve decentralizepy by adding
more implementations of modules derived from recent and upcoming research.

##  3\. Evaluation

In this section, we demonstrate the power of decentralizepy by implementing
changing topologies, state-of-the-art sparsification algorithms, secure
aggregation in DL, and a scalability study.

###  3.1. Experimental Setup

The experiments are run on 16 hyperthreading-enabled machines equipped with 2
Intel(R) Xeon(R) CPU E5-2630 v3 @ 2.40GHz having 8 cores. Based on the
experiment, we run 48, 256, or 1024 DL nodes (processes). Each process is
constrained to one logical CPU core in the experiments. The nodes are
oblivious about being on the same or different machines and communicate via
TCP sockets using ZeroMQ (Boccassi et al., 2023). We tuned the learning-rate
for the basic stochastic gradient descent (SGD) optimizer without momentum,
and use it for training along with cross-entropy loss. The DL clients used
decentralized parallel stochastic gradient descent (D-PSGD) (Lian et al.,
2017) over Metropolis-Hastings weights (Xiao et al., 2007) for aggregation. We
use CIFAR-10 (Krizhevsky et al., 2014) dataset with a 2-sharding non-IID data
partitioning (McMahan et al., 2017) which limits the number of classes per
node to 4. In addition to CIFAR-10, we also use CelebA (Caldas et al., 2019)
for secure-aggregation experiments. The evaluation is done on the test-set of
the respective datasets. We run each experiment 5 times with different random
seeds and present the average metrics with a 95% confidence interval.

###  3.2. Topologies and Dynamicity

The performance of DL is heavily influenced by the communication topology
(Koloskova et al., 2020a). We now demonstrate how decentralizepy can flexibly
simulate different topologies. We start by running decentralizepy with 256
learning nodes on a ring, d-regular with degree 5, and fully-connected static
topologies. The framework allows us to effortlessly change topologies for the
experiments by only replacing the graph file described in Section 2.2. To
simulate dynamic topologies, decentralizepy uses a centralized peer sampler
which instantiates new topologies every round using the graph module. Any
dynamic graph can be realized within the peer sampler which then notifies each
node of its neighbors. We demonstrate a sample case where the peer sampler
creates a random 5-regular topology every round.

Figure 3 shows the convergence plots with respect to the communication rounds,
wall-clock time, and the cumulative bytes sent per node when run for the same
number of communication rounds. As one would expect, fully connected has the
highest accuracy and the ring has the lowest accuracy at the end (Figure 3
(a)). decentralizepy also reveals that experiments with fully-connected
topologies take nearly $3\times$ more time when compared to the rest for the
same number of communication rounds (Figure 3 (b)). This detail is often not
evaluated in literature due to limited framework support. We observe that
d-regular topologies represent a favorable tradeoff between the extreme
topologies (Figure 3 (b) and (c)). Dynamic topologies perform much better than
their static counterparts. Moreover, dynamic 5-regular topology achieves
almost identical accuracies to fully-connected given the same time deadline
while having $51\times$ less communication cost. Therefore, research should
focus more on dynamic topologies to study their tradeoffs in more detail.

Figure 4. Performance of a 256-node DL comparing the sparsification algorithms
of _random sampling_ and Choco-SGD to _full sharing_. The communication budget
is set to 10% and we run all algorithms for the same number of communication
rounds. We observe that data non-IIDness and the scale of nodes significantly
hurt the performance of sparsification algorithms. Under the same
communication budget, full sharing tends to be robust and achieves higher
accuracy.

###  3.3. Sparsification

DL systems use sparsification algorithms to reduce the number of bytes
exchanged in the network (Alistarh et al., 2018; Lin et al., 2018). In
sparsification, a communication budget specifies the percentage of model
parameters shared by nodes with respect to full sharing, sharing all
parameters. We now showcase how decentralizepy supports commonly-used
sparsification algorithms as part of the sharing module. In full sharing, the
basic sharing module generates a serialized parameter vector to be sent to
neighboring nodes. For sparsification, in contrast, we modify basic sharing to
generate serialized tuples of the indices and values of the parameters chosen
to be shared. For the experiments, we consider a setup with a 5-regular
topology of 256 learning nodes with a communication budget of $10\%$.

Figure 4 shows the test accuracy vs. communication cost of two sparsification
algorithms: (1) random sampling, and (2) hyperparameter-tuned state of the art
Choco-SGD (Koloskova et al., 2019) against the baseline of full sharing DL.
The random sampling algorithm picks 10% random parameters every round for
sharing. Choco-SGD uses sophisticated parameter-ranking and error-correction
schemes to limit the loss of information due to sparsification. We observe
that sparsification loses too much information and performs significantly
worse than full sharing. This can be attributed to the complexity of the
learning task. The convergence of sparsification algorithms drastically slows
down in non-IID settings with a large number of nodes. To reach the same
accuracy as both sparsification algorithms, full sharing uses significantly
less communication. Most works studying sparsification algorithms are often
evaluated in IID settings with a limited number of nodes, resulting in overly
optimistic estimations of the performance (Hsieh et al., 2020). The use of
decentralizepy will enable researchers to study sparsification algorithms that
are robust to difficult data distributions at scale.

Figure 5. Performance of a 48-node DL comparing Secure Aggregation with
standard DL without secure aggregation (D-PSGD). We observe that Secure
Aggregation achieves comparable accuracy to D-PSGD on the CelebA dataset while
it loses 3% absolute accuracy on CIFAR-10 (first row). The privacy guarantees
of Secure Aggregation come at a modest cost in additional communication
(second row).

###  3.4. Secure Aggregation

The well-established technique of secure aggregation (Bonawitz et al., 2017),
commonly used in centralized settings, ensures that participating nodes only
have access to the aggregated model parameters, while keeping private the
individual models of other training nodes. This is achieved through the
masking of parameters where pairs of nodes add cancellable masks to their
respective models before sharing. The receiver node upon aggregation gets the
same aggregated model as one without secure aggregation. However, the masks
prevent access to individual models. Through a non-trivial implementation
(Vujasinovic, 2023), we show that decentralizepy can also be leveraged to
perform such secure aggregation in the DL setting. We design the core
procedure as part of the node module of decentralizepy and conduct experiments
with $48$ nodes on CIFAR-10 and CelebA datasets for $10\,000$ communication
rounds.

Figure 5 shows the test accuracy vs. cumulative communication cost of DL with
and without secure aggregation. Secure aggregation incurs approximately $3\%$
more communication due to metadata (shared seeds for pseudo-random number
generation and masks) in addition to the parameters. Furthermore, because
masks and parameters are floating point numbers, there is a loss of precision
which leads to $3\%$ loss in accuracy.

Figure 6. Performance of a 256-node and 1024-node DL setups with varying
degrees of d-regular topologies. Since the total dataset size remains the same
when the nodes are scaled, each node receives $4\times$ fewer data samples in
the 1024-node setup. We observe that 5-regular topology achieves the same
performance in both 256- and 1024-node setups, suggesting that degree might be
more influential than the number of data samples per node in DL. Further
increasing the degree to 9 benefits accuracy by almost 6%.

###  3.5. Scalability

Finally, we perform a scalability study of DL by increasing the number of
nodes from 256 to 1024. In this study, we particularly analyze the effect of
the number of data samples per node and the degree of the node on the
performance of DL. Since the underlying dataset size remains the same when the
nodes are scaled, each node receives $4\times$ fewer data samples in the setup
with 1024 nodes compared to the setup with 256 nodes.

We report the evolution of test accuracy for 256-node 5-regular, 1024-node
5-regular, and 1024-node 9-regular topologies in Figure 6. It is worth noting
that the final performance of the 5-regular topology with $1024$ and $256$
nodes remain almost the same, even with non-IID data and $4\times$ fewer data
samples in the 1024-node setting. Increasing the degree from $5$ to $9$ boosts
the performance by $5.8$ accuracy points on average. This suggests that the
number of neighbors has a higher impact on learning than the number of data
samples per node. Such novel insights are possible through advanced
scalability studies, thanks to decentralizepy. We highlight that
decentralizepy can run a much higher number of nodes relative to the relevant
literature in decentralized learning systems (Bellet et al., 2022; Vogels et
al., 2022; Zhu et al., 2022; Vogels et al., 2020; Koloskova et al., 2019).

##  4\. Related work

Flower (Beutel et al., 2020) is a framework for FL emulation. Like
decentralizepy, Flower scales to one thousand nodes training in parallel. It
is however limited to the FL setup, , it relies on a central server that
orchestrates the ML training by collecting and aggregating client models on
every iteration. In addition, it does not offer seamless support for arbitrary
communication topologies.

FedScale (Lai et al., 2022) is both a collection of realistic datasets (with
natural non-IID and unbalanced data) and a runtime platform that supports
cluster and mobile back-ends. In simulation mode, FedScale orchestrates
execution requests over available resources (either single GPU/CPU or
distributed) while keeping a _client virtual clock_. This way, it achieves
shorter evaluation times in comparison to the simulated scenario and reports
up to $10\,000$ training nodes in parallel on top of a cluster of 10 GPU
nodes. In addition, FedScale incorporates system speeds and availability
traces of mobile devices to achieve realistic heterogeneity simulations.
Unlike decentralizepy, it has no support for DL.

IPLS (Pappas et al., 2021) proposes ML training that uses a decentralized
filesystem as the communication channel. To reduce network traffic while
ensuring some fault tolerance, they also propose model partitioning and
replication of partitions across nodes. Each node only shares a particular set
of layers (rather than the whole model) and each layer is potentially shared
by several nodes. Its feasibility is yet to be confirmed, as authors show a
very small deployment (50 nodes) with a simple learning task (MNIST) on top of
IID data. Moreover, IPLS depends on the underlying IPFS (Benet, 2014)
implementation and is therefore not flexible in terms of topology
manipulation.

Kollaps (Gouveia et al., 2020) is a decentralized network emulator that allows
for the manipulation of end-to-end communication properties between nodes. By
shaping the network latency, bandwidth, packet loss, and jitter, they achieve
very similar results of bare-metal deployments in geo-distributed setups.
Kollaps is orthogonal and complementary to decentralizepy, as it operates at
the level of containers (, Docker) and orchestrators (, Kubernetes).

Closer to our proposal, FedML (He et al., 2020) is a Federated Learning
framework that provides several baseline implementations of models and
datasets for reproducible research and benchmarking. FedML supports distinct
topologies, including decentralized ones. Since it uses MPI (Message Passing
Interface Forum, 2021) for communication, it is primarily targeted to cluster
environments. decentralizepy, in contrast, can be smoothly deployed in WAN and
is more flexible than FedML in terms of dynamic topologies.

##  5\. Conclusion

Research in DL systems requires efficient scaling to many nodes, ease of
deployment, and a quick development cycle. In this paper, we present
decentralizepy, a DL framework designed to support these requirements. Its
modular design facilitates the replacement of components with customized ones,
allowing rapid prototyping and deployment.

We demonstrate the power, flexibility, and scalability of decentralizepy
through a series of experiments across different topologies, sparsification
algorithms, and privacy-preserving secure aggregation. Using this framework,
we were able to derive new insights concerning the effectiveness of dynamic
topologies and the performance degradation of state-of-the-art sparsification
algorithms on non-IID learning tasks at scale.

decentralizepy has been used by over a dozen students for projects in DL.
Their feedback has been valuable in improving the usability and efficiency of
the framework. We expect the scientific community to also try and contribute
to it. As future work, we plan to extend decentralizepy with real-world traces
of network traffic over Kollaps (Gouveia et al., 2020), client availability
from FedScale (Lai et al., 2022), and decentralized peer sampling (Jelasity et
al., 2007). We also plan to integrate additional state-of-the-art DL
algorithms, including quantization and topology construction. Finally, using
the framework as a platform, the community can build communication-efficient
and privacy-preserving DL systems that are robust to non-IID data
distributions at scale.

## References

  * (1)
  * Abadi et al. (2016) Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek G. Murray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. 2016\.  TensorFlow: a system for Large-Scale machine learning _(OSDI’16)_.  https://www.usenix.org/conference/osdi16/technical-sessions/presentation/abadi
  * Alistarh et al. (2017) Dan Alistarh, Demjan Grubic, Jerry Z. Li, Ryota Tomioka, and Milan Vojnovic. 2017.  QSGD: Communication-Efficient SGD via Gradient Quantization and Encoding _(NIPS’17)_.  https://proceedings.neurips.cc/paper_files/paper/2017/file/6c340f25839e6acdc73414517203f5f0-Paper.pdf
  * Alistarh et al. (2018) Dan Alistarh, Torsten Hoefler, Mikael Johansson, Sarit Khirirat, Nikola Konstantinov, and Cédric Renggli. 2018.  The Convergence of Sparsified Gradient Methods _(NIPS’18)_.  https://proceedings.neurips.cc/paper_files/paper/2018/file/314450613369e0ee72d0da7f6fee773c-Paper.pdf
  * Bars et al. (2023) Batiste Le Bars, Aurélien Bellet, Marc Tommasi, Erick Lavoie, and Anne-Marie Kermarrec. 2023.  Refined Convergence and Topology Learning for Decentralized Optimization with Heterogeneous Data _(AISTATS’23)_.  arXiv:2204.04452
  * Bellet et al. (2022) Aurélien Bellet, Anne-Marie Kermarrec, and Erick Lavoie. 2022.  D-Cliques: Compensating for Data Heterogeneity with Topology in Decentralized Federated Learning _(SRDS’22)_.  https://doi.org/10.1109/SRDS55811.2022.00011
  * Benet (2014) Juan Benet. 2014\.  IPFS - Content Addressed, Versioned, P2P File System.  _CoRR_ (2014).  arXiv:1407.3561
  * Beutel et al. (2020) Daniel J Beutel, Taner Topal, Akhil Mathur, Xinchi Qiu, Titouan Parcollet, and Nicholas D Lane. 2020.  Flower: A Friendly Federated Learning Research Framework.  (2020).  arXiv:2007.14390
  * Boccassi et al. (2023) Luca Boccassi et al. 2023\.  ZeroMQ: An open-source universal messaging library.  https://zeromq.org
  * Bonawitz et al. (2019) Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, et al. 2019\.  Towards Federated Learning at Scale: System Design _(MLSys’19)_.  https://proceedings.mlsys.org/paper_files/paper/2019/file/bd686fd640be98efaae0091fa301e613-Paper.pdf
  * Bonawitz et al. (2017) Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H. Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. 2017.  Practical Secure Aggregation for Privacy-Preserving Machine Learning _(CCS ’17)_.  https://doi.org/10.1145/3133956.3133982
  * Caldas et al. (2019) Sebastian Caldas, Peter Wu, Tian Li, Jakub Konečný, H. Brendan McMahan, Virginia Smith, and Ameet Talwalkar. 2019.  Leaf: A benchmark for federated settings. In _2nd Intl. Workshop on Federated Learning for Data Privacy and Confidentiality_ _(FL-NeurIPS’19)_.  arXiv:1812.01097
  * Dhasade et al. (2022) Akash Dhasade, Nevena Dresevic, Anne-Marie Kermarrec, and Rafael Pires. 2022.  TEE-based decentralized recommender systems: The raw data sharing redemption _(IPDPS’22)_.  https://doi.org/10.1109/IPDPS53621.2022.00050
  * Gouveia et al. (2020) Paulo Gouveia, João Neves, Carlos Segarra, Luca Liechti, Shady Issa, Valerio Schiavoni, and Miguel Matos. 2020.  Kollaps: Decentralized and Dynamic Topology Emulation _(EuroSys ’20)_. Article 23\.  https://doi.org/10.1145/3342195.3387540
  * He et al. (2020) Chaoyang He, Songze Li, Jinhyun So, Mi Zhang, Hongyi Wang, Xiaoyang Wang, Praneeth Vepakomma, Abhishek Singh, Hang Qiu, Li Shen, Peilin Zhao, Yan Kang, Yang Liu, Ramesh Raskar, Qiang Yang, Murali Annavaram, and Salman Avestimehr. 2020.  FedML: A research library and benchmark for federated machine learning.  (2020).  arXiv:2007.13518
  * Hsieh et al. (2020) Kevin Hsieh, Amar Phanishayee, Onur Mutlu, and Phillip B. Gibbons. 2020.  The Non-IID Data Quagmire of Decentralized Machine Learning. In _Proceedings of the 37th International Conference on Machine Learning_ _(ICML’20)_. Article 408\.  http://proceedings.mlr.press/v119/hsieh20a/hsieh20a.pdf
  * Jelasity et al. (2007) Márk Jelasity, Spyros Voulgaris, Rachid Guerraoui, Anne-Marie Kermarrec, and Maarten Van Steen. 2007\.  Gossip-based peer sampling.  _ACM Transactions on Computer Systems (TOCS)_ 25, 3 (2007), 8–es.
  * Kairouz et al. (2020) Peter Kairouz, H. Brendan McMahan, Brendan Avent, Aurélien Bellet, Mehdi Bennis, Arjun Nitin Bhagoji, Kallista Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, Rafael G. L. D’Oliveira, Hubert Eichner, Salim El Rouayheb, David Evans, Josh Gardner, Zachary Garrett, Adrià Gascón, Badih Ghazi, Phillip B. Gibbons, Marco Gruteser, Zaid Harchaoui, Chaoyang He, Lie He, Zhouyuan Huo, Ben Hutchinson, Justin Hsu, Martin Jaggi, Tara Javidi, Gauri Joshi, Mikhail Khodak, Jakub Konecný, Aleksandra Korolova, Farinaz Koushanfar, Sanmi Koyejo, Tancrède Lepoint, Yang Liu, Prateek Mittal, Mehryar Mohri, Richard Nock, Ayfer Özgür, Rasmus Pagh, Hang Qi, Daniel Ramage, Ramesh Raskar, Mariana Raykova, Dawn Song, Weikang Song, Sebastian U. Stich, Ziteng Sun, Ananda Theertha Suresh, Florian Tramèr, Praneeth Vepakomma, Jianyu Wang, Li Xiong, Zheng Xu, Qiang Yang, Felix X. Yu, Han Yu, and Sen Zhao. 2020\.  Advances and open problems in federated learning.  _Foundations and Trends in Machine Learning_ 14, 1–2 (2020).  https://doi.org/10.1561/2200000083
  * Koloskova et al. (2020a) Anastasia Koloskova, Tao Lin, Sebastian U Stich, and Martin Jaggi. 2020a.  Decentralized Deep Learning with Arbitrary Communication Compression _(ICLR’20)_.  https://openreview.net/forum?id=SkgGCkrKvH
  * Koloskova et al. (2020b) Anastasia Koloskova, Nicolas Loizou, Sadra Boreiri, Martin Jaggi, and Sebastian Stich. 2020b.  A Unified Theory of Decentralized SGD with Changing Topology and Local Updates _(ICML’20)_.  https://proceedings.mlr.press/v119/koloskova20a.html
  * Koloskova et al. (2019) Anastasia Koloskova, Sebastian Stich, and Martin Jaggi. 2019\.  Decentralized stochastic optimization and gossip algorithms with compressed communication _(ICML’19)_.  https://proceedings.mlr.press/v97/koloskova19a.html
  * Krizhevsky et al. (2014) Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. 2014\.  The CIFAR-10 dataset.  55, 5 (2014).  https://www.cs.toronto.edu/~kriz/cifar.html
  * Lai et al. (2022) Fan Lai, Yinwei Dai, Sanjay Singapuram, et al. 2022\.  FedScale: Benchmarking Model and System Performance of Federated Learning at Scale _(ICML’22)_.  https://proceedings.mlr.press/v162/lai22a.html
  * Lian et al. (2017) Xiangru Lian, Ce Zhang, Huan Zhang, Cho-Jui Hsieh, Wei Zhang, and Ji Liu. 2017\.  Can Decentralized Algorithms Outperform Centralized Algorithms? A Case Study for Decentralized Parallel Stochastic Gradient Descent _(NIPS’17)_.  https://proceedings.neurips.cc/paper_files/paper/2017/file/f75526659f31040afeb61cb7133e4e6d-Paper.pdf
  * Lin et al. (2018) Yujun Lin, Song Han, Huizi Mao, Yu Wang, and Bill Dally. 2018.  Deep Gradient Compression: Reducing the Communication Bandwidth for Distributed Training _(ICLR’18)_.  https://openreview.net/forum?id=SkhQHMW0W
  * Liu et al. (2021) Yang Liu, Tao Fan, Tianjian Chen, Qian Xu, and Qiang Yang. 2021.  FATE: An Industrial Grade Platform for Collaborative Learning With Data Protection.  _J. Mach. Learn. Res._ 22, 226 (2021).  http://jmlr.org/papers/v22/20-815.html
  * McMahan et al. (2017) Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. 2017\.  Communication-efficient learning of deep networks from decentralized data _(AISTATS’17)_.  https://proceedings.mlr.press/v54/mcmahan17a/mcmahan17a.pdf
  * Message Passing Interface Forum (2021) Message Passing Interface Forum. 2021\.  _MPI: A Message-Passing Interface Standard Version 4.0_.  https://www.mpi-forum.org/docs/mpi-4.0/mpi40-report.pdf
  * Pappas et al. (2021) Christodoulos Pappas, Dimitris Chatzopoulos, Spyros Lalis, and Manolis Vavalis. 2021.  IPLS: A Framework for Decentralized Federated Learning _(IFIP Networking’21)_.  https://doi.org/10.23919/IFIPNetworking52078.2021.9472790
  * Paszke et al. (2019) Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. 2019.  PyTorch: An Imperative Style, High-Performance Deep Learning Library.  In _NeurIPS’19_.  https://proceedings.neurips.cc/paper_files/paper/2019/file/bdbca288fee7f92f2bfa9f7012727740-Paper.pdf
  * Roth et al. (2022) Holger R Roth, Yan Cheng, Yuhong Wen, Isaac Yang, Ziyue Xu, YuanTing Hsieh, Kristopher Kersten, Ahmed Harouni, Can Zhao, Kevin Lu, Zhihong Zhang, Wenqi Li, Andriy Myronenko, Dong Yang, Sean Yang, Nicola Rieke, Abood Quraini, Chester Chen, Daguang Xu, Nic Ma, Prerna Dogra, Mona G Flores, and Andrew Feng. 2022.  NVIDIA FLARE: Federated Learning from Simulation to Real-World. In _Workshop on Federated Learning: Recent Advances and New Challenges_.  https://openreview.net/forum?id=hD9QaIQTL_f
  * Sharma et al. (2022) Rishi Sharma et al. 2022\.  decentralizepy: An open-source decentralized learning research framework.  https://github.com/sacs-epfl/decentralizepy
  * Strom (2015) Nikko Strom. 2015\.  Scalable distributed DNN training using commodity GPU cloud computing. In _16th Annual Conference of the International Speech Communication Association_ _(INTERSPEECH’15)_.  https://www.isca-speech.org/archive_v0/interspeech_2015/papers/i15_1488.pdf
  * Vogels et al. (2022) Thijs Vogels, Hadrien Hendrikx, and Martin Jaggi. 2022\.  Beyond spectral gap: the role of the topology in decentralized learning _(NeurIPS’22)_.  https://proceedings.neurips.cc/paper_files/paper/2022/file/61162d94822d468ee6e92803340f2040-Paper-Conference.pdf
  * Vogels et al. (2020) Thijs Vogels, Sai Praneeth Karimireddy, and Martin Jaggi. 2020\.  Practical Low-Rank Communication Compression in Decentralized Deep Learning _(NeurIPS’20)_.  https://proceedings.neurips.cc/paper_files/paper/2020/file/a376802c0811f1b9088828288eb0d3f0-Paper.pdf
  * Vujasinovic (2023) Milos Vujasinovic. 2023\.  _Secure Aggregation on Sparse Models in Decentralized Learning Systems_.  Master’s thesis. EPFL.  https://www.epfl.ch/labs/sacs/wp-content/uploads/2023/02/Secure_Aggregation_on_Sparse_Models_in_Decentralized_Learning_Systems___Milos_Vujasinovic.pdf
  * Xiao et al. (2007) Lin Xiao, Stephen Boyd, and Seung-Jean Kim. 2007.  Distributed average consensus with least-mean-square deviation.  _J. Parallel and Distrib. Comput._ 67, 1 (2007).  https://doi.org/10.1016/j.jpdc.2006.08.010
  * Yang et al. (2018) Timothy Yang, Galen Andrew, Hubert Eichner, Haicheng Sun, Wei Li, Nicholas Kong, Daniel Ramage, and Françoise Beaufays. 2018.  Applied federated learning: Improving google keyboard query suggestions.  (2018).  arXiv:1812.02903
  * Zhu et al. (2022) Tongtian Zhu, Fengxiang He, Lan Zhang, Zhengyang Niu, Mingli Song, and Dacheng Tao. 2022\.  Topology-aware generalization of decentralized SGD _(ICML’22)_.  https://proceedings.mlr.press/v162/zhu22d.html
  * Ziller et al. (2021) Alexander Ziller, Andrew Trask, Antonio Lopardo, et al. 2021\.  PySyft: A library for easy federated learning.  In _Federated Learning Systems_.  https://doi.org/10.1007/978-3-030-70604-3_5

  *[ML]: machine learning
  *[DL]: decentralized learning
  *[FL]: federated learning
  *[LAN]: local area network
  *[IID]: independent and identically distributed
  *[non-IID]: non independent and identically distributed
  *[SGD]: stochastic gradient descent
  *[D-PSGD]: decentralized parallel stochastic gradient descent
  *[WAN]: wide area network


# Differential configurational complexity and phase transitions of the BPS
solutions in the O(3)-sigma model

F. C. E. Lima  E-mail<EMAIL_ADDRESS>Universidade Federal do
Ceará (UFC), Departamento do Física - Campus do Pici, Fortaleza, CE, C. P.
6030, 60455-760, Brazil.  C. A. S. Almeida  E-mail<EMAIL_ADDRESS>Universidade Federal do Ceará (UFC), Departamento do Física - Campus do Pici,
Fortaleza, CE, C. P. 6030, 60455-760, Brazil.

###### Abstract

Using a spherically symmetric ansatz, we show that the Chern-Simons O(3)-sigma
model with a logarithmic potential admits topological solutions. This result
is quite interesting since the Gausson-type logarithmic potential only
predicted topological solutions in $(1+1)$D models. To accomplish our goal,
the Bogomol’nyi-Prasad-Sommerfield (BPS) method is used, to saturate the
energy and obtain the BPS equations. Next, we show by the numerical method is
the graphical results of the topological fields, as well as, the magnetic
field behavior that generates a flux given by
$\Phi_{flux}=-\mathcal{Q}/\kappa$ and the energy density of the structures of
vortices. On the other hand, we evaluate the measure of the differential
configurational complexity (DCC) of the topological structures, by considering
the energy density of the vortex. This analysis is important because it will
provide us with information about the possible phase transitions associated
with the localized structures and it shows that our model only supports one
phase transition.

##  I Introduction

The non-linear sigma model is a set of scalar fields mapped in a target space,
where the fields are coordinates. In 1981, Alvarez-Gaumme and D. Freedman
alvarez  used the target space as a Riemannian manifold for gauging of the
space’s isometries. Subsequently, other works consolidated the method of
Alveraz-Gaumme and D. Freedman hull1 , hull2 , jack , CA . The initial
motivation of the research on the sigma model was to apply it to conformal
field theory and superstring models. Posteriorly, Schroers schroers
investigates topological solitons using a breaking the scale invariance by
gauging the subgroup U(1) of the O(3)-sigma model. In their paper, to build a
field theory with BPS properties, the Maxwell term and scalar potential were
used. Soon after, P. Ghosh and S. Ghosh ghosh  included a Chern-Simons term in
the model. Several works in the following years treat the subject under many
viewpoints muk1 , CA2 , rothe . Recently, the gauged O(3)-sigma model was
readdressing in the context of Lorentz symmetry breaking models casana1 ,
casana2  and in several approaches of new kinds of Bogomol’nyi-Prasad-
Sommerfield (BPS) solutions casana2020 , barto .

It is interesting to mention here that the gauging of symmetry is used in the
approach of the so-called Skyrme model to break the scale invariance. In
principle, the Skyrme model is the non-linear sigma model generalized as the
sigma model is invariant under the group SO(3), the Skyrme model will be too.
In fact, for the Skyrme model to be invariant under the group SO(3), gauging
the subgroup U(1) is necessary. This gauging will generate a coupling of the
scalar field to the gauge field Gladi . The result is a (3+1)D Skyrme-Maxwell
model, which is a rich physical model predicting the proton-neutron mass
difference durgut . In (2+1)D, the version of the Skyrme model is known as the
baby-Skyrme modelpiette .

The BPS approach Bogomol'nyi  allows us to study the field solutions
topological and non-topological. Indeed, the BPS method is a series of
inequalities of a homotopic class of solutions of a partial differential
equation in the spatial infinite. In the context of topological defects, the
BPS limit is represented by a saturation limit of the energy of the model
Bogomol'nyi , Atmaja . When the energy reaches the saturation limit, the
equations of motion are known as BPS equations, and the order of these
equations is reduced from second to first order Bogomol'nyi .

Several works have considered the dynamics of the Chern-Simons gauge field to
study the BPS solutions ghosh , Arthur , Gladi2 , Kimm , Lima , Lima1 . These
systems become self-dual for a suitable potential Jackiw , Jackiw1 , LA11 ,
LA12 , so their topological Horvathy  and non-topological solutions Spruck
will be present in the model.

In this work, we will introduce for the first time a logarithmic potential in
the $O(3)$-sigma model context. The logarithmic potential produces solitonic
solutions in bidimensional models Belendryasova . Recently the studies
indicate that the logarithmic potential can generate ring-like vortices with
intense magnetic flux when the Higgs field lies coupled to the gauge field
Lima2 , LPA1 , LPA2 . However, the first works on relativistic theories are
due by G. Rosen Rosen , Rosen1 , Bialynicki-Birula, and Mycielski (BBM) in the
context of Schrödinger theories BBM . For their Gaussian shape, BBM called
Gaussons the soliton-like solutions of the Schrödinger equation with
logarithmic nonlinearity. Inspired by them, we called the Chern-Simons
O(3)-sigma model with a logarithmic potential of Chern-Simons-Gausson
O(3)-sigma model.

On the other hand, we can find some applications of the logarithmic potential
in several models Zloshch1 , Zloshch2 , Zloshch3 . An attractive application
of this theory arises when we consider an electrical charge with a self-
consistent configuration used for describing logarithmic quantum Bose liquids
Vladimir . In this case, the electromagnetic field interacts with the physical
vacuum. Also, models with the so-called gausson logarithmic term were used to
describe theories of quantum gravity Konstantin1 , as well as quantum effects
in nonlinear quantum theory Konstantin2 .

We introduced, throughout the work, the discussion of the differential
configurational complexity (DCC) of BPS vortices in an Abelian model. DCC is a
variant of configurational entropy (CE) that appeared in Ref. Gleiser3 ,
underpinned by the information theory of Claude E. Shannon Shannon . From a
quantum-mechanical viewpoint, Shannon’s entropy is interested in giving us
information on the probability of a particle evolving from one quantum state
to another LRC . CE and its variants are responsible for offering us
information about the stability measure applied to a localized structure. The
applications of this theory are vast. For example, the CE is used to
investigate stable Q-ball solutions Gleiser4 , Gleiser5  at the Chandrasekhar
limit for white dwarfs, in the study of the non-equilibrium dynamics of
spontaneous symmetry breaking Gleiser5 , in the study of Bose-Einstein
condensates Casadio , and in braneworlds to investigate multi-kink type field
configurations Wilami , MLA .

The other purpose of this work is to investigate the existence of stationary
solutions and calculate the DCC in the $O(3)$-sigma model coupled to the
Chern-Simons (CS) field and subject to a kind of nonpolynomial potential.
Using the DCC, we investigated the possible existence of phase transitions
that can create new topological structures in the model.

We organized this paper as follows: In the Sec. II, a review of the gauged
O(3)-sigma model with Chern-Simons term is present. In Sec. III, the
definition of the Chern-Simons-Gausson O(3)-sigma model, is implemented. Also,
we investigated their stationary solutions using a numerical approach. Then,
in Sec. IV, we investigate the DCC and analyze the possible phase transitions
of the BPS structures. Finally, in Sec. V, our findings are announced.

##  II The gauged $O(3)$-sigma model with Chern-Simons term

We started our investigation considering a Lagrangian density in flat space-
time in $(2+1)$D as proposed in Refs. ghosh , Belendryasova , given by

$\displaystyle\mathcal{L}=\frac{1}{2}D_{\mu}\Phi\cdot
D^{\mu}\Phi+\frac{\kappa}{4}\varepsilon^{\mu\nu\lambda}A_{\mu}F_{\nu\lambda}-V(\phi_{3}).$
(1)

where $V(\phi_{3})$ is the potential and the component $\phi_{3}$ is the field
configuration responsible for the spontaneous breaking of the symmetry of the
model.

The O(3)-sigma model is well-known in the specialized literature as the result
of a mapping of two unit spheres, denoted by $S^{2}$ Rajaraman . It is
essential to mention that due to this mapping, the field $\Phi$ of the
$O(3)$-sigma model must respect the constraint

$\displaystyle\Phi\cdot\Phi=1\rightarrow\phi_{1}^{2}+\phi_{2}^{2}+\phi_{3}^{2}=1.$
(2)

Due to the choice of a potential of the type $V(\phi_{3})$, the Lagrangian
must be invariant to an isorotation of the preference axis $\hat{n}_{3}$, i.
e., $\hat{n}_{3}=(0,0,1)$.

We must define the covariant derivative of the model as

$\displaystyle D_{\mu}\Phi=\partial_{\mu}\Phi+A_{\mu}\hat{n}_{3}\times\Phi.$
(3)

The U(1) nature of the model can be seen by the following identity

$\displaystyle D_{\mu}\Phi\cdot
D^{\mu}\Phi=|(\partial_{\mu}+iA_{\mu})(\phi_{1}+i\phi_{2})|^{2}+\partial_{\mu}\phi_{3}\partial^{\mu}\phi_{3}.$
(4)

We will assume that our metric signature will be $\eta_{\mu\nu}=$
diag$(+,-,-)$ with $\varepsilon^{012}=1$; $\mu,\nu=0,1,2$ and $i,j=1,2$.

By investigating the equations of motion, we will have

$\displaystyle\textbf{J}^{\mu}=-\Phi\times D^{\mu}\Phi,$ (5)

where the local current is given by
$\textbf{J}^{\mu}=-j^{\mu}\cdot\hat{n}_{3}$ and

$\displaystyle
j^{\mu}=\frac{\kappa}{2}\varepsilon^{\mu\nu\lambda}F_{\nu\lambda}.$ (6)

The $j^{0}$ component is known as Gauss’ law. In this way, the field
configurations carry a magnetic flux and a non-zero charge given by
$\mathcal{Q}=-\kappa\Phi_{flux}$.

Similarly, the equation of motion for the scalar field will be

$\displaystyle D_{\mu}D^{\mu}\Phi=-\frac{\partial V}{\partial\Phi}.$ (7)

Therefore, we can write

$D_{\mu}\textbf{J}^{\mu}=\Phi\times\frac{\partial V}{\partial\Phi}.$ (8)

Considering that the $T_{00}$ component of the energy-momentum tensor
represents the energy density of the model, we have

$\displaystyle
T_{00}=\mathcal{E}=\frac{1}{2}(D_{1}\Phi)^{2}+\frac{1}{2}(D_{2}\Phi)^{2}+\frac{\kappa^{2}F_{12}^{2}}{2(1-\phi_{3}^{2})}+V,$
(9)

with the energy that describes the vortex configurations being

$\displaystyle E=\int\,d^{2}x\,\mathcal{E}.$ (10)

##  III The Chern-Simons O(3)-sigma model with logarithmic potential

To study the static field configurations at the BPS bound, i. e., vortex
configurations. Let us rewrite the energy density as

$\displaystyle\mathcal{E}=\frac{1}{2}(D_{i}\Phi\pm\varepsilon_{ij}\Phi\times
D_{j}\Phi)^{2}+\frac{\kappa^{2}}{2(1-\phi_{3}^{2})}\bigg{[}F_{12}\mp\sqrt{\frac{2(1-\phi_{3}^{2})V}{\kappa^{2}}}\bigg{]}^{2}\pm
4\pi\mathcal{Q}_{0}.$ (11)

Now, we define the topological charge as

$\displaystyle\mathcal{Q}_{\mu}=\frac{1}{8\pi}\varepsilon_{\mu\nu\lambda}\bigg{[}\Phi\cdot
D^{\nu}\Phi\times
D^{\lambda}\Phi+F^{\nu\lambda}\sqrt{\frac{2\kappa^{2}V}{(1-\phi_{3}^{2})}}\bigg{]}.$
(12)

In this way, the energy density is

$\displaystyle\mathcal{E}=\frac{1}{2}(D_{i}\Phi\pm\varepsilon_{ij}\Phi\times
D_{j}\Phi)^{2}+\frac{\kappa^{2}}{2(1-\phi_{3}^{2})}\bigg{[}F_{12}\mp\sqrt{\frac{2(1-\phi_{3}^{2})V}{\kappa^{2}}}\bigg{]}^{2}\pm
4\pi\mathcal{Q}_{0}.$ (13)

Considering that the energy is the integration of $T_{00}$ in all space, we
will therefore have

$\displaystyle E=$
$\displaystyle\frac{1}{2}\int\,d^{2}x\,\bigg{\\{}(D_{i}\Phi\pm\varepsilon_{ij}\Phi\times
D_{j}\Phi)^{2}+\frac{\kappa^{2}}{2(1-\phi_{3}^{2})}\bigg{[}F_{12}\mp\sqrt{\frac{2(1-\phi_{3}^{2})V}{\kappa^{2}}}\bigg{]}^{2}\bigg{\\}}$
$\displaystyle\pm 4\pi\int\,d^{2}x\,\mathcal{Q}_{0}.$ (14)

Allow us to define the BPS energy as

$\displaystyle E=\pm 4\pi\int\,d^{2}x\,\mathcal{Q}_{0}.$ (15)

Perceive that the energy of the vortex is limited, i. e.,

$\displaystyle E\geq E_{BPS}.$ (16)

At the bound of saturation of the energy, the static field configurations obey
the first order Bogomol’nyi equations, given by:

$\displaystyle D_{i}\Phi=\mp\varepsilon_{ij}\Phi\times D_{j}\Phi,$ (17)

and

$\displaystyle F_{12}=\pm\sqrt{\frac{2(1-\phi_{3}^{2})V}{\kappa^{2}}}.$ (18)

At this moment, let us assume that the potential of the theory is given by

$\displaystyle
V(\phi_{3})=\frac{\kappa^{2}}{2}\phi_{3}^{2}\text{ln}\bigg{(}\frac{\phi_{3}^{2}}{\vartheta^{2}}\bigg{)}.$
(19)

This potential is known as Gausson’s potential. In truth, this term is due to
the Gaussian form of the soliton-like solutions of the Schrödinger equation
with logarithmic interaction. Bialynicki-Birula and Mycielski BBM  were the
first to use the term Gausson. Here, the parameters $\kappa$ and $\vartheta$
adjust the dimension of the model, and the factor $\kappa^{2}/2$ is
conveniently applied to get the BPS bound. Also, note from Fig. (1) that the
parameter $\vartheta$ is associated with the vacuum state of the model.

Figure 1: Potential for several values of $\vartheta$.

The potential (19), allows us to rewrite Eq. (18) as

$\displaystyle
F_{12}=\pm\sqrt{(1-\phi_{3}^{2})\phi_{3}^{2}\text{ln}\bigg{(}\frac{\phi_{3}^{2}}{\vartheta^{2}}\bigg{)}}.$
(20)

###  III.1 Static vortex solutions

Due to the constraint of the $O(3)$-sigma model, we choose a spherical
symmetry for the variable field. This means that

$\displaystyle\phi_{1}=\sin{f(r)}\cos{N\theta},$
$\displaystyle\phi_{2}=\sin{f(r)}\sin{N\theta},$ (21)
$\displaystyle\phi_{3}=\cos{f(r)}.$

Meanwhile, the gauge field is

$\displaystyle\textbf{A}(\rho,\theta)=-\frac{Na(r)}{\kappa
r}\hat{e}_{\theta}.$ (22)

Considering the self-dual potential (19), the ansatz for the scalar field
(III.1) and the ansatz for the gauge field (22), we recast Bogomol’nyi’s
equations as

$\displaystyle f^{\prime}(r)=\pm N\frac{a+1}{r}\sin{f(r)},$ (23)

and

$\displaystyle
a^{\prime}(r)=\pm\frac{r}{N}\sqrt{\cos{f(r)}^{2}\sin{f(r)}^{2}\text{ln}\bigg{(}\frac{\cos{f(r)}^{2}}{\vartheta^{2}}\bigg{)}}.$
(24)

####  III.1.1 Asymptotic analysis

From now on, we are interested in investigating the topological vortex
structures of the model. In other words, we will investigate the solutions of
the equations (23) and (24). To ensure that the variable field has no
singularity at the origin, we consider that the field near the origin has the
form

$\displaystyle f(0)=n\pi,\hskip 28.45274ptn\in\mathbb{N}.$ (25)

For this behavior of the variable field $f(r)$ near the origin, the gauge
field must assume the behavior $a(0)\rightarrow 0$. It is interesting to
mention that the solutions of the variable field are symmetric under
$f(r)=2\pi$.

We are interested in investigating topological solutions, i. e., solutions
with non-zero and finite energy configurations. For this, we are interested in
field configurations that respect the conditions

$\displaystyle f(0)=0\hskip 28.45274pt\text{and}\hskip 28.45274ptf(\pi)=\pi.$
(26)

Considering the condition $f(0)=0$, it is very useful to use the
transformation $f(r)=\pi+\xi(r)$. We use the negative sign of the Bogomol’nyi
equations and assumed structures with positive vorticity, i. e., $N>0$.
Without losing generality, being $\xi(r)\ll 1$, the model assumes solutions of
the type

$\xi(r)=A_{0}r^{N}.$ (27)

Consequently, the solution of the gauge field is

$a(r)\simeq-\frac{A_{0}}{N(N+2)(N+3)}r^{N+3}\sqrt{\text{ln}\bigg{(}\frac{1}{\vartheta}\bigg{)}}+\mathcal{O}(r),$
(28)

where $\mathcal{O}(r)$ are the high order terms of $r$.

On the other hand, if we consider that $f(0)=0$ and $N<0$, we can assume that

$f(r)=\bar{B_{0}}r^{-N}.$ (29)

In this case, the solution for the gauge field is

$a(r)\simeq-\frac{\bar{B_{0}}}{N(2-N)}r^{2-N}\sqrt{\text{ln}\bigg{(}\frac{1}{\vartheta}\bigg{)}}+\mathcal{O}(r).$
(30)

At infinity, there are two asymptotic behaviors in Bogomol’nyi’s equations.
First, when $f(\infty)=\pi$, we can again write $f(r)=\pi+\xi(r)$ and obtain
the localized energy solutions with $a(\infty)=\eta_{1}$. That way, we can
assume

$\xi(r)=C_{\infty}r^{N(1-\eta_{1})}.$ (31)

As result, we have that

$a(r)\simeq-\frac{C_{\infty}}{[N(1-\eta_{1})+2]}r^{[N(1-\eta_{1})+2]}\sqrt{\text{ln}\bigg{(}\frac{1}{\vartheta^{2}}\bigg{)}}-\eta_{1}.$
(32)

Finally, when analyzing the conditions:

$\displaystyle f(\infty)=0\hskip 28.45274pt\text{and}\hskip
28.45274pta(\infty)=\eta_{2}$ (33)

with $N<0$, we have

$f(r)=\bar{C}_{\infty}r^{N(1+\eta_{2})}.$ (34)

Consequently, we obtain

$a(r)=-\frac{\bar{C}_{\infty}}{N[N(1+\eta_{2})+2]}r^{[N(1+\eta_{2})+2]}\sqrt{\text{ln}\bigg{(}\frac{1}{\vartheta^{2}}\bigg{)}}+\eta_{2}.$
(35)

The parameters $\eta_{1}$ and $\eta_{2}$ indicate whether the solutions are
topological or non-topological.

####  III.1.2 The numerical results

We return our attention to the numerical study of the scalar and gauge fields.
To achieve our purpose, we consider the fields described by respective Eqs.
(23) and (24). Also, we will use a numerical interpolation method with the
topological conditions (26). It is shown in Fig. 2(a) the result of the scalar
field.

On the other hand, with the help of the equation (24), we can obtain the
graphic behavior of the Chern-Simons field associated with vortex structures
and represented in Fig. 2(b).

(a) (b)

Figure 2: Topological solution of the $O(3)$-sigma model with logarithmic
potential. (a) The result of the scalar field. (b) The result of the gauge
field.

Using the numerical solutions of the variable field and the gauge field, we
can describe the physical properties of the structure, namely: BPS energy
density and magnetic field. Considering the solutions displayed in Figs. 2(a)
and 2(b) we obtain the BPS energy density of the vortex. Let us remember that
to obtain the BPS energy density is necessary to use the equation (9). Fig.
3(a), is exposed the numerical result of the BPS energy density.

(a) (b)

Figure 3: (a) The BPS energy density of the vortex. (b) The magnetic field of
the vortex.

Adopting the expression (20), we obtain the magnetic field (Fig. 3(b)) of the
vortex structures. The numerical results allow reaching the kink-like
topological vortex structures. We can see that this structure has a finite and
positive-defined energy density with very significant intensity. This result
is because the vortices of the model interact with the Chern-Simons field
generating a flux due to the magnetic induction shown in Fig. 3(b).

Finally, to calculate DCE and its variants is usual to use the BPS vortex
solutions, see Ref. LA12 . It is essential to highlight that this is because
these quantities, in truth, are defined by a Fourier transform of the energy
density (in our case, the BPS energy density). Indeed, the results of the CE
and its variants provide information about the model parameters so that it is
possible to detect stable field configurations Gleiser , Gleiser1 , Gleiser2 ,
see Sec. IV. In the study of BPS structures, the CE will inform us which
values of the BPS topological configurations are stable or more likely. The
information about the DCC and phase transitions will be relevant to complement
our discussion of the BPS solutions obtained in this section. In general, the
study of the information theory in this context will give us information about
the stability of the solutions of the BPS vortex found.

##  IV DCC of the vortex

The configurational entropy (CE) gives us a measure of the informational
complexity of a localized field configuration. The CE, DCE, and DCC are
amounts formulated as Fourier transforms of the energy density, see Refs.
Gleiser , Gleiser1 , Gleiser2 , Wilami . In fact, the CE has been studied
intensively in several cosmological scenarios correia , Correia5 , CLee . With
this in mind, to understand the vortex structure and the possible existence of
phase transitions of the BPS solutions, we propose the study of the DCC of the
model.

From Refs. Gleiser , Gleiser1 , Gleiser2 , Gleiser3 , we define the concept of
differential entropy as

$\displaystyle\mathcal{S}=\int\,\rho(\mbox{\boldmath{$\omega$}})\ln[\rho(\mbox{\boldmath{$\omega$}})]\,d\mbox{\boldmath{$\omega$}}.$
(36)

It is worth noting that the DCC is not invariant under a change of
coordinates. As a consequence of this, the probability density transforms like
a scalar density under the coordinate transformations $x\to\tilde{x}$, see
Ref. GS1 .

Considering the localized energy density $\mathcal{E}(\textbf{r})$, we define
in D-dimensional space the decomposition of the wave modes as

$\displaystyle\mathcal{F}(\mbox{\boldmath{$\omega$}})=(2\pi)^{-(d/2)}\int\mathcal{E}(\textbf{r})\text{e}^{-i\mbox{\boldmath{$\omega$}}\cdot\textbf{r}}\,d^{d}\textbf{r}.$
(37)

The contribution of wave mode to a $|\mbox{\boldmath{$\omega$}}_{\star}|$ is
the modal fraction, namely,

$\displaystyle
f(\mbox{\boldmath{$\omega$}})=\frac{|\tilde{\mathcal{F}}(\mbox{\boldmath{$\omega$}})|^{2}}{|\tilde{\mathcal{F}}(\mbox{\boldmath{$\omega$}}_{\star})|^{2}}.$
(38)

The DCC is defined as

$\displaystyle\mathcal{S_{C}}=-\int\,f(\mbox{\boldmath{$\omega$}})\ln[f(\mbox{\boldmath{$\omega$}})]\,d^{d}\mbox{\boldmath{$\omega$}},$
(39)

note that the above integral is positive definite since
$g(\mbox{\boldmath{$\omega$}})\leq 1$.

Due to the symmetry of our model, it is convenient to write the DCC in
spherical symmetry, which lets us remember that the hyperspherical Fourier
transform is given by

$\displaystyle\mathcal{F}=\omega^{1-\frac{d}{2}}\int_{0}^{\infty}\,\mathcal{E}(r)J_{\frac{d}{2}-1}(\omega
r)r^{d/2}\,dr,$ (40)

with $\mathcal{E}(r)$ the BPS energy density of the vortex and $J_{\nu}$ the
Bessel function.

Using (40), we have that the DCC is

$\displaystyle\mathcal{S_{C}}=\frac{2\pi^{d/2}}{\Gamma(\frac{d}{2})}\int_{0}^{\infty}\,\omega^{d-1}f(\omega)\ln[f(\omega)]\,d\omega,$
(41)

where the entropic density $\rho(\omega)$ is the integrand of the DCC.

In the context of the braneworlds, the above quantity can describe new
topological structures, e. g. multi-kink solutions, which are the fruits of
multiples phase transition Wilami . Using the DCC to study the topological
structures, we want to understand whether our vortex solutions are unique and
whether it permits multiple transitions.

The calculation of the DCC is not easy since our energy density of the
O(3)-sigma is given by

$\displaystyle\mathcal{E}=\frac{1}{2}D_{i}\Phi\cdot
D^{i}\Phi+\frac{\kappa^{2}F_{12}^{2}}{2(1-\phi_{3})}+\frac{\kappa^{2}}{2}\phi_{3}\text{ln}\frac{\phi_{3}^{2}}{\vartheta^{2}},$
(42)

and

$\displaystyle\Phi=\phi_{i}(f(r);r)\hat{\text{e}}\,^{i}\,\,\,\,\,\text{with}\,\,\,\,\,i=1,2,3.$
(43)

Although of the difficulties, we evaluate the modal fraction numerically of
the model and show the results in Figs. 4(a) and (b). To obtain the modal
fraction, we consider the numerical solutions of Eqs. (23) and (24). First, we
perceive that the parameter $\vartheta$, which relates the potential to the
magnetic field, will directly influence the modal fraction. In this way, the
increase of the parameter $\vartheta$ produces an exponential decrease of the
modal fraction (amplitude) of the BPS vortex. By simulation, we also noticed
the amplitude of the first node in figs. 4(a) and (b) correspond to the
solution discussed in the previous section.

(a) (b)

Figure 4: (a) Modal fraction when $\vartheta$ is constant. (b) Modal fraction
when $\kappa$ is constant.

Using the numerical solution of the modal fraction, we investigate the
configurational entropy density (entropic density) of the model. In the
neighborhood of the core of the BPS vortex ($r\approx 0$), we observed
entropic densities are higher for parameters $\kappa$ and $\vartheta$ fixed.
In fact, due to the localized structure being in $r=0$, the entropic density
is high in this region. The parameter $\vartheta$ is responsible for the
control entropic density and the magnetic field. In truth, when this parameter
increases, the magnetic field decreases, leading to decay of the modal
fraction (Figs. 4) and the entropic density (Figs. 5).

(a) (b)

Figure 5: (a) Configurational entropy density when $\vartheta$ is constant.
(b) Configurational entropy density when $\kappa$ is constant.

Finally, the results of the DCC of the BPS vortex (Fig. 6) allow us to observe
that the Chern-Simons-Gausson O(3)-sigma model admits only a type of solution,
namely, the kink-like solution. In Fig. 2(a), we exposed this solution. Due to
the DCC profile of the O(3)-sigma model, we observed that the Chern-Simons-
Gausson O(3)-Sigma model does not support multiple phase transitions. Also, it
is possible to see that the critical point of the DCC corresponds to the
vacuum expected value of the theory.

Figure 6: Configurational entropy of the BPS vortex.

##  V Concluding remarks

In this work, we studied the vortex topological structures of the O(3)-sigma
model. In our model, we coupled the field configuration of the sigma model to
the Chern-Simons with logarithmic interaction. We show that the topological
structures are kink-like solutions due to the spherical symmetry of the
problem. As a consequence of this result, the vortices generated are
magnetically charged and have a magnetic flux given by
$\Phi_{flux}=-\mathcal{Q}/\kappa$. Finally, numerically was observed that the
vortices generated are quite energetic. Indeed, this is due to the
contribution of the logarithmic potential and the Chern-Simons field.

Once we obtain the BPS solution of the sigma model, we find the spatial
profile of the energy density of the model. We investigated whether the
studied vortices admitted multiple phase transitions. We observed that the DCC
assumed a profile type of a directional delta-function centered approximately
on the expected value of the vacuum state. Due to this profile of the DCC, it
is clear that the model does not support multiple phase transitions. In fact,
due to the behavior of the DCC and the probability densities, we note that the
model supports other solutions, however, these solutions will differ only “how
quickly” the fields evolve into a vacuum state.

By numerical analysis, we perceived entropy densities are higher where the
vortex is localized. Indeed, examining the parameters $\kappa$ and $\vartheta$
note that the influence of the vortex structures makes their energetic flux
higher (or smaller) as the field is more (or less) localized.

## Acknowledgment

The authors thank the Conselho Nacional de Desenvolvimento Científico e
Tecnológico (CNPq), grant No. 308638/2015-8 (CASA), and Coordenação de
Aperfeiçoamento do Pessoal de Nível Superior (CAPES) for financial support.

## References

  * [1] L. Alvarez-Gaumme and D. Freedman, Commun. Math. Phys. 80, (1981) 443.
  * [2] C. Hull and E. Witten, Phys. Lett. B 160, (1985) 398.
  * [3] C. Hull and B. Spence, Phys. Lett. B 232, (1989) 204.
  * [4] I. Jack, D. Jones, N. Mohammedi and H. Osborn, Nucl. Phys. B 332, (1990) 359.
  * [5] C. A. S. Almeida, J. A. Helayel-Neto and A. William Smith, Phys. Lett. B 279, (1992) 75.
  * [6] B. Schroers, Phys. Lett. B 356, (1995) 291.
  * [7] P. Ghosh and S. Ghosh, Phys. Lett. B 366, (1996) 199.
  * [8] P. Mukherjee, Phys. Lett. B 403, (1997) 70.
  * [9] F. S. A. Cavalcante, M. S. Cunha and C. A. S. Almeida, Phys. Lett. B 475, (2000) 315.
  * [10] Soon-Tae Hong and K. Rothe, Ann. Phys. 311, (2004) 417.
  * [11] R. Casana, C. F. Farias and M. M. Ferreira, Jr., Phys. Rev. D 92, (2015) 125024.
  * [12] R. Casana, C. F. Farias, M. M. Ferreira, Jr. and G. Lazar, Phys. Rev. D 94, (2016) 065036.
  * [13] R. Casana, A. Santos and M. Dias, Phys. Rev. D 102, (2020) 085002.
  * [14] D. Bartolucci, Y. Lee, Chang-Shoun Lin and M. Onoodera, Annales de l’Institut Henri Poincaré C 32, (2015) 651.
  * [15] J. Gladikowski, B. M. A. G. Piette and B. J. Schroers, Phys. Rev. D 53, (1996) 844.
  * [16] M. Durgut and N. K. Pak, Phys.Lett. B159, (1985) 357 and errata in Phys.Lett. B 162, (1985) 405.
  * [17] B. Piette, B. J. Schroers and W.J. Zakrzewski, Nucl.Phys. B 439, (1995) 205.
  * [18] E. B. Bogomol’nyi, Sov. J. Nucl. Phys. 24, (1976) 449.
  * [19] A. N. Atmaja and H. S. Ramadhan, Phys. Rev. D 90, (2014) 105009.
  * [20] K. Arthur, Phys. Lett. B 385, (1996) 181.
  * [21] J. Gladikowski, Z. Phys. C 73, (1996) 181.
  * [22] K. Kimm, K. Lee and T. Lee, Phys. Rev. D 53, (1996) 181.
  * [23] F. C. E. Lima, D. M. Dantas and C. A. S. Almeida, Europhys. Lett. 130, (2020) 10005.
  * [24] F. C. E. Lima, D. A. Gomes and C. A. S. Almeida, Ann. Phys. 422, (2020) 168315.
  * [25] R. Jackiw and E. J. Weinberg, Phys. Rev. D 64, (1990) 2234.
  * [26] R. Jackiw, K. Lee and E. J. Weinberg, Phys. Rev. D 42, (1990) 3488.
  * [27] F. C. E. Lima and C. A. S. Almeida, Phys. Lett. B 829, (2022) 137042.
  * [28] F. C. E. Lima and C. A. S. Almeida, Eur. Phys. J. C 81, (2021) 1044.
  * [29] P. A. Horvathy and P. Zhang, Phys. Rep. 481, (2009) 83.
  * [30] J. Spruck and Y. Yang, Comm. Math. Phys. 149, (1992) 361.
  * [31] E. Belendryasova, V. A. Gani and K. G. Zloshchastiev, J. Phys.: Conf. Ser. 1390, (2019) 012082.
  * [32] F. C. E. Lima, and C. A. S. Almeida, Europhys. Lett. 131, (2020) 31003.
  * [33] F. C. E. Lima, A. Yu. Petrov and C. A. S. Almeida, Phys. Rev. D 103, (2021) 096019.
  * [34] F. C. E. Lima, A. Yu. Petrov and C. A. S. Almeida, Phys. Rev. D 105, (2022) 056005.
  * [35] G. Rosen, J. Math. Phys. 9, (1968) 996.
  * [36] G. Rosen, J. Phys. Math. 9, (1968) 999.
  * [37] I. Bialynick-Birula and J. Mycielski, J. Phys. Scr. 20, (1979) 539.
  * [38] K. G. Zloshchastiev, Europhys. Lett. 122, (2018) 39001.
  * [39] K. G. Zloshchastiev, Acta Phys. Polon. B 42, (2011) 261.
  * [40] K. G. Zloshchastiev, Universe 6, (2020) 180.
  * [41] V. Dzhunushaliev and K. Zloshchastiev, Open Physics 11, (2013) 325.
  * [42] K. G. Zloshchastiev, Gravitation and Cosmology 16, (2010) 288.
  * [43] K. G. Zloshchastiev, Phys. Lett. A 375, (2011) 2305.
  * [44] M. Gleiser and N. Stamatopoulos, Phys. Lett. B 713, (2012) 304.
  * [45] C. E. Shannon, The Bell system technical journal, 27, (1948) 379.
  * [46] F. C. E. Lima, A. R. P. Moreira and C. A. S. Almeida, Int. J. Quantum Chem. 121, (2021) e26645.
  * [47] M. Gleiser and D. Sowinski, Phys. Lett. B 727, (2013) 272.
  * [48] M. Gleiser and N. Stamatopoulos,Phys. Rev. D 86, (2012) 045004.
  * [49] R. Casadio and R. da Rocha,Phys. Lett. B 763, (2016) 434.
  * [50] W. T. Cruz, D. M. Dantas, R. V. Maluf and C. A. S. Almeida. Ann. Phys. 531, (2019) 1900178.
  * [51] A. R. P. Moreira, F. C. E. Lima and C. A. S. Almeida, Thick branes phase transitions in $f(T,B)$ gravity, arXiv:2110.08585 (2021)
  * [52] R. Rajaraman, Solitons and instantons, North-Holland Phys. Pub. 1st ed. (1982).
  * [53] M. Gleiser, M. Stephens and D. Sowinski, Phys. Rev. D 97, (2018) 096007.
  * [54] M. Gleiser, D. Sowinski,Phys. Lett. B 727, (2013) 272.
  * [55] M. Gleiser, N. Graham, Phys. Rev. D 89, (2014) 083502.
  * [56] R. A. C. Correa and P. H. R. S. Moraes, Eur. Phys. J. C, 76, (2016) 100.
  * [57] M. Chinaglia, W. T. Cruz, R. A. C. Correa, W. de Paula and P. H. R. S. Moraes, Phys. Lett. B 779, (2018) 16.
  * [58] C. O. Chong, Phys. Lett. B 790, (2019) 197.
  * [59] M. Gleiser and D. Sowinski, Phys. Rev. D 98, (2018) 056026.


# low-alpha operation of the iota storage ring

M. Wallbank<EMAIL_ADDRESS>J. Jarvis  Fermi National Accelerator Laboratory
Batavia  IL  USA

###### Abstract

Operation with ultra-low momentum-compaction factor (alpha) is a desirable
capability for many storage rings and synchrotron radiation sources. For
example, low-alpha lattices are commonly used to produce picosecond bunches
for the generation of coherent THz radiation and are the basis of a number of
conceptual designs for EUV generation via steady-state microbunching (SSMB).
Achieving ultra-low alpha requires not only a high-level of stability in the
linear optics but also flexible control of higher-order compaction terms.
Operation with lower momentum-compaction lattices has recently been
investigated at the IOTA storage ring at Fermilab. A procedure for lowering
the ring compaction using the linear optics along with compensations from the
higher-order magnets was developed with the aid of a model, and an
experimental technique for measuring the momentum compaction was developed.
The lowest momentum compaction achieved during the available run-time was
$3.4\times 10^{-4}$, around 15 times lower than previously operated. These
feasibility studies ensure an improved experimental understanding of the IOTA
optics and potentially will enable new research programs at the facility.

##  1 INTRODUCTION

The Integrable Optics Test Accelerator (IOTA) [1] is a 40 m storage ring at
the Fermilab Accelerator Science and Technology (FAST) [2] facility, designed
for flexible beam R&D. The research program includes exploring Non-linear
Integrable Optics, beam cooling, space-charge effects, single-electron studies
and AI/ML for machine operations. The ring may be injected with electrons
accelerated to energies of $50-100$ MeV by a superconducting linac, or with
$2.5$ MeV protons from a duoplasmatron source currently undergoing
commissioning. There are six sextupole families located at different points
around the ring, and nine consecutive octupoles in one straight section.

The momentum compaction $\alpha_{c}$ of a ring describes the variation in
orbit length $\Delta C$ relative to the design orbit $C_{0}$ experienced by
particles at momentum deviations $\delta=(p-p_{0})/p_{0}$, where $p$ and
$p_{0}$ are respectively the particle momentum and the reference momentum,
which to third order is written:

$\Delta C/C_{0}=\alpha_{1}\delta+\alpha_{2}\delta^{2}+\alpha_{3}\delta^{3}.$
(1)

The leading-order term $\alpha_{1}$ is determined by the linear optics, and
the higher-order terms can be controlled and corrected by successively higher-
order magnets.

Establishing low-alpha operation of the IOTA ring will enable the development
of new accelerator lattice designs which could potentially facilitate new
areas of research, and additionally improve confidence in the stability of all
experimental lattices through a better understanding of the ring optics. To
support these goals, a short experimental feasibility study aiming to reach a
compaction of $1.0\times 10^{-4}$ and demonstrate control over the three
leading-order terms was carried out at the end of IOTA Run4 (150 MeV
electrons) in Fall 2023.

##  2 LOW-ALPHA STORAGE RING MOTIVATIONS

The primary motivations for exploring low-alpha configurations of the IOTA
optics were: to support the ongoing Optical Stochasic Cooling (OSC)
experimental program [3]; to investigate improved phase space acceptance for
injection or storage; and to enable new research programs which rely on low-
alpha lattices as a fundamental requirement.

The OSC lattice is designed to be low-emittance, to increase the effects of
the cooling, which naturally leads to a lower momentum compaction. In the
first phase of the experimental program, there were unresolved problems
establishing injection into the lattice until the optics were modified to
slightly increase the compaction. Whilst not investigated at the time, it is
possible these issues stemmed from higher-order compaction terms left
uncompensated by the non-linear optics. An improved understanding of
controlling these higher-order terms will ensure the best possibility of
success in future OSC runs.

As the compaction is reduced, the areas of stable longitudinal phase space are
modified and new stable fixed points, so-called alpha buckets, are formed at
non-zero $\delta$ and at a phase of $\pi$ with respect to the RF bucket. For a
given lattice, there exists a maximally-stable configuration which particles
can populate with significantly longer lifetimes. Accessing these areas of
phase space could be utilized in the injection or storage of particles in the
IOTA ring to support greater beam currents and lifetimes [4].

Low-alpha lattices are a fundamental requirement for steady-state
microbunching (SSMB), a highly active area of research with great promise as a
next-generation light source technology [5, 6]. In SSMB, very short
substructure is created within a bunch stored in a ring, which persists and is
reinforced through successive turns. Through the use of a radiator placed at a
strategic location, it is conceptually possible to create high power, high
frequency radiation comparable to that from a free-electron laser with the
high repetition rate of a storage ring.

##  3 OPTICAL STOCHASTIC CRYSTALLIZATION

OSC is a state-of-the-art beam cooling technology first demonstrated
experimentally at IOTA in 2021 [7]. It extends the well-established stochastic
cooling technique from microwave to optical bandwidths, enabling significantly
increased cooling rates. The ‘transit-time’ method of OSC [8] utilizes
undulators for both the ‘pickup’ and ‘kicker’ components, which respectively
produce radiation from a bunch and enables subsequent downstream interactions
between the particles and their radiation. The radiation contains information
about the longitudinal distribution of the bunch particles to enable
corrective energy exchanges in the kicker. Between the undulators, the beam is
directed through a dispersive section to convert momentum discrepancies to a
longitudinal spread, whilst the light passes through optics to refocus and
optionally amplify the radiation. The system is phased such that a particle at
the reference momentum will arrive in time with its own radiation and thus
feel no corrective kicks; particles with an energy discrepancy will gain or
lose energy to the radiation fields so that they move closer to the reference
energy. Over time and multiple passes through the system, the bunch is
effectively cooled. The cooling rate is dependent on the bandwidth of the
system; that is, how narrow the bunch is sampled to ensure particles are not
impacted by others spatially nearby in the kicker. Additionally, the mechanism
relies on sufficient randomization of particles between the kicker and the
pickup to ensure collective effects are not enforced. The fundamental
mechanism was demonstrated very successfully without the use of an optical
amplifier, and a second phase of the program including an amplifier is
currently being designed and scheduled to operate in 2025.

An OSC system can be operated to produce longitudinal structure at the optical
wavelength, which can lead to SSMB with a mutually configured storage ring; we
refer to this as Optical Stochastic Crystallization (OSX). The mechanism works
by instead ensuring insufficient randomization of particles, which leads to
strong, self-reinforcing collective effects due to each particle feeling the
wake of all neighbors within the system bandwidth. This is demonstrated in
Figure 1.

Figure 1: Demonstration of the OSX mechanism using a simple 1D simulation,
with three snapshots shown left to right. The top panels show the radiation
produced by initialized randomized particles, and the superposition of all the
radiation is shown in the bottom panels.

To promote and sustain SSMB via OSX within a storage ring, the following is
required: sufficient gain in the OSC system from optical amplification to
initiate the formation of substructure; sufficiently low momentum compaction
with the same sign as the OSC bypass; and minimal transverse-longitudinal
coupling at the undulators, for example by ensuring the dispersion invariant
is sufficiently small. Results from a simple 1D simulation is shown in Figure
2, demonstrating the formation of the substructure over successive passes
through the ring. A first experimental demonstration of this concept is
planned during the next OSC experimental run in 2025.

Figure 2: Snapshots from a simple 1D simulation demonstrating the formation of
microstructure at the optical wavelength. The top two panels show the
longitudinal phase space, and the power components at harmonics of the optical
frequency are shown in the lower panels.

##  4 LOW-ALPHA DEMONSTRATIONS AT IOTA

###  4.1 Compaction Measurements

During the initial studies at IOTA, the momentum compaction was estimated from
the synchrotron frequency during an RF detuning scan. For an applied shift in
the RF frequency, $\Delta f_{rf}/f_{rf}$, the synchrotron frequency depends on
the various orders of momentum compaction as [9]

$\displaystyle f_{s}^{2}$
$\displaystyle=\frac{hq_{e}V_{rf}f_{0}^{2}\absolutevalue{\eta_{1}\cos{\phi_{s}}}}{2\pi\beta_{0}^{2}E_{0}}\left[1+\frac{s_{1}}{\eta_{1}}\left(\frac{\Delta
f_{rf}}{f_{rf}}\right)+\frac{s_{2}}{\eta_{1}^{2}}\left(\frac{\Delta
f_{rf}}{f_{rf}}^{2}\right)\right]$ (2) $\displaystyle s_{1}$
$\displaystyle=-\frac{2\eta_{2}-\eta_{1}^{2}}{\eta_{1}}+\frac{1}{\gamma_{0}^{2}}$
$\displaystyle s_{2}$
$\displaystyle=\frac{3\eta_{3}\eta_{1}-2\eta_{2}^{2}}{\eta_{1}^{2}}-\frac{\eta_{2}}{\eta_{1}\gamma_{0}^{2}}+\frac{3\gamma_{0}^{2}\beta_{0}^{2}+2}{2\gamma_{0}^{4}},$

where $h$, $V_{r}f$ and $\phi_{s}$ are the RF harmonic, voltage and
synchronous phase respectively, $f_{0}$ is the revolution frequency in the
ring, $q_{e}$ is the electron charge, and $E_{0}$ is the beam energy. The
compaction here is given as the slip factor, $\eta$, which very well
approximates $\alpha$ in the highly-relativistic case.

The synchrotron frequency was calculated from the sidebands around the 11th
harmonic of the RF frequency, measured online by a spectrum analyzer attached
to a wall current monitor. At low compaction, the AC power line frequencies at
harmonics of 60 Hz complicated the measurement, though could relatively easily
be filtered out. This method was found to work extremely well down to the
lowest compactions measured.

###  4.2 Low-Alpha Investigations

The accelerator lattice was adapted from the primary version used during IOTA
Run4, with an initial momentum compaction of $1\times 10^{-2}$. A strategy to
reduce the compaction with the linear optics was developed through the use of
a model, and the impact of the non-linear magnets on the higher-order terms
was also well characterized.

The impact of applying successive linear optics knobs, designed to reduce the
compaction, is shown in Figure 3. Each fit represents one scan at a single
lattice configuration. The reduction in the compaction is clear, with the
impact of the $\alpha_{2}$ and $\alpha_{3}$ terms resulting in a higher-order
polynomial relationship becoming visible as $\alpha_{c}$ is reduced.

Figure 3: Impact of a linear optics knob designed to reduce the momentum
compaction after successive applications. The leading three $\alpha_{c}$ terms
are shown in the legend.

At high compaction, the ability of the sextupoles to sweep the second-order
term $\alpha_{2}$ through zero is shown in Figure 4. At lower compaction,
resulting from the application of four of the linear optics knobs, the ability
of the octupoles to vary the third-order term $\alpha_{3}$ through zero is
shown in Figure 5. These demonstrations illustrate the required control over
the momentum compaction terms from the non-linear optics is acheivable at
IOTA.

Figure 4: Impact of one sextupoles family (SD1) on $\alpha_{c}$ at high
compaction (no linear optics knobs applied). Figure 5: Impact of the octupoles
on $\alpha_{c}$ at lower momentum compaction. All nine octupoles are energized
in series. For this scan, the sextupoles are used to provide some $\alpha_{2}$
compensation.

In order to reach low compactions, the linear optics must be reduced gradually
whilst applying the relevant non-linear compensation to ensure stability and
sustained lifetime. Following this procedure, a compaction of $3.4\times
10^{-4}$ was reached. The initial aim of $1.0\times 10^{-4}$, and subsequently
crossing transition to negative compaction, were not possible given the
available experimental time, but the experience gained ensures confidence that
these goals are possible.

##  5 CONCLUSION

Low-alpha operation of the IOTA storage has been demonstrated for the first
time, validating the requirements on the beam optics to reach ultra-low
momentum compactions. The experience ensures confidence in the next OSC
experiments, which includes a first demonstration of Optical Stochastic
Crystallization and steady-state microbunching. The improved understanding of
the beam optics will support all ongoing physics programs and potentially
allow enhanced standard operational modes and new areas of research.

##  6 ACKNOWLEDGMENTS

We would like to thank Aleksandr Romanov, Nathan Eddy, Daniel Broemmelsiek,
and Giulio Stancari for useful discussions and help with detector
instrumentation and lattice commissioning. This manuscript has been authored
by Fermi Research Alliance, LLC under Contract No. DE-AC02-07CH11359 with the
U.S. Department of Energy, Office of Science, Office of High Energy Physics.

## References

  * [1] S. Antipov et al., “IOTA (Integrable Optics Test Accelerator): Facility and Experimental Beam Physics Program”, JINST, 12, T03002, 2017.
  * [2] Fermilab Accelerator and Science Technology, fast.fnal.gov
  * [3] V. Lebedev et al., “The design of Optical Stochastic Cooling for IOTA”, JINST, 16, T05002, 2021.
  * [4] M. Ries, “Nonlinear Momentum Compaction and Coherent Synchrotron Radiation at the Metrology Light Source”, Ph.D. Thesis, Humboldt University of Berlin, Department of Physics, 2014.
  * [5] D. Ratner, A. W. Chao, “Steady-State Microbunching in a Storage Ring for Generating Coherent Radiation”, Phys. Rev. Lett. 105, 154801, 2010.
  * [6] X. Deng et al., “Experimental demonstration of the mechanism of steady-state microbunching”, Nature 590, 576, 2021.
  * [7] J. Jarvis et al., “Experimental demonstration of optical stochastic cooling”, Nature 608, 287, 2022.
  * [8] M.S. Zolotorev, A.A. Zholents, “Transit-time method of optical stochastic cooling”, Phys. Rev. E, 50, 3087, 1994.
  * [9] H. Hama, S. Takano, G. Isoyama, “Control of the bunch length on an electron storage ring”, Nucl. Instrum. Methods Phys. Res. A329, 29, 1993.