# Software in P2P way: a software model without central software and enabling
any software to join or leave freely

Hong Su H. Su is with School of Computer Science, Chengdu University of
Information Technology, Chengdu, China. E-mail<EMAIL_ADDRESS>

###### Abstract

The P2P model encompasses a network of equal peers, whether in hardware or
software, operating autonomously without central control, allowing individual
peer failure while ensuring high availability. Nevertheless, current P2P
technologies primarily focus on hardware-level resilience, often referred to
as P2P networks, which do not safeguard against software failures. This paper
introduces a pioneering Peer-to-Peer (P2P) software model aimed at enhancing
software-level high availability. Diverging from prevalent hardware-centric
P2P technologies, this model accentuates the decentralized nature of various
software components, or ”software peers,” which function independently,
enabling seamless network entry and exit without relying on central software.
The model’s collaborative approach cultivates a network topology with multiple
autonomous processing paths, ensuring continuous operation through dynamic
task allocation in a distributed manner. By surpassing the limitations of
traditional redundancy methods, this P2P model provides an adaptive and
scalable solution for achieving robust availability. Validation results
underscore the model’s effectiveness in enhancing the probabilities of
successful task processing while ensuring high availability.

###### Index Terms:

P2P software model, System resilience, Independent software, High availability

##  I Introduction

Ensuring high availability is critical for the stability and functionality of
any system, particularly in domains where system reliability directly impacts
critical operations. Industries such as finance, healthcare, and
telecommunications rely heavily on uninterrupted services, emphasizing the
pivotal role of high availability in sustaining business continuity and
enhancing the user experience [1]. Recent studies highlighting the increased
reliance on cloud-based infrastructures further emphasize the need for robust
high availability strategies to prevent service disruptions and data loss,
ultimately safeguarding against revenue loss and reputational damage [2]. By
implementing comprehensive high availability measures, organizations can
effectively mitigate the risks associated with system downtime and ensure
seamless, uninterrupted operations, thereby strengthening their competitive
edge in a dynamic and interconnected marketplace.

Peer-to-Peer (P2P) networks, known for their decentralized structure and
resilience to individual peer failures, have primarily focused on hardware
resilience, neglecting the critical aspect of software-level high
availability. Although hardware-centric P2P technologies have facilitated
resilient networking, the prevalence of software vulnerabilities and failures
in modern computing environments remains a persistent challenge. As reliance
on software systems continues to grow, the necessity for a comprehensive
software-level high availability framework within P2P networks becomes
increasingly evident.

While such architectures might leverage distributed hardware environments like
clouds or P2P setups, their capacity to avert system outages is largely
limited to hardware failures within specific hardware subsets, rather than
accounting for potential vulnerabilities in the software domain. The current
software model is characterized by: (1) employing a singular software for task
handling, or (2) utilizing multiple software components coordinated by a
specific software, or (3) incorporating multiple software pieces featuring
identical or akin binary code. This architectural framework inherently fosters
singularities at the software level. Additionally, some backup software might
be employed (similar to N-version programming), but this entails a fixed count
of software instances, precluding the freedom for software to seamlessly join
or depart.

To address these issues, this paper introduces a Peer-to-Peer (P2P) software
model. The P2P system comprises a set of software that collaboratively
establishes a network architecture devoid of singular task processing
pathways, enabling seamless software replacement. Termed software peers, these
softwares possess the characteristics of independent operation, freedom from
central coordination, and autonomous development. Within the P2P system,
multiple processing paths ensure task continuity even in the face of the
failures of some paths.

This model brings forth two key advantages: (1) The availability of multiple
processing paths eliminates singularities, enhancing task processing
reliability. These paths, formed by different softwares that are independently
designed, coded, and verified, forge a network structure that amplifies task
success probabilities. (2) The model facilitates the integration of new
software alongside existing counterparts, enabling a smoother task transition
between them upon failures, resulting in heightened availability.

This paper’s contributions are threefold:

  1. 1.

We propose the P2P software model, composed of independent softwares that
operate without central coordination, with each software functioning as a
self-reliant software peer. These software peers offer distinct processing
paths, with task switching mechanisms activated upon failures. The predecessor
software handles path switching, eliminating the need for central control and
enhancing path redundancy.

  2. 2.

We introduce a layered P2P model, enabling finer-grained interactions among
software. This approach, partitioning software into layers, promotes task
switching within layers rather than software shifts, leading to augmented
processing paths and network topology. This stratified structure enhances task
processing efficiency, success rates, and adaptability to intricate tasks.

  3. 3.

We propose a method to evaluate P2P model availability through topology
analysis. By representing the P2P model as a graph elucidating interactions
among software peers, we identify coupled paths and optimize performance
metrics such as task time and success probability. This topology-based
approach offers insights into path relationships, enhancing overall model
availability.

The remainder of this paper is organized as follows. Section II presents
related work. Sections III and IV describe the P2P software model and P2P
topology, respectively. Section IV describes the validation results, and
Section V concludes the paper.

##  II Related Work

The central objective of this paper is to enhance system availability by
leveraging the peer-to-peer (P2P) software model, establishing independent
redundancy at the software level and facilitating seamless transitions to
alternate processing paths. To provide context, we begin with an overview of
pertinent research on redundancy, focusing on hardware and P2P technology.
Subsequently N-version programming and conduct a comparative assessment are
explored. Additionally, alternative strategies pursued to achieve heightened
availability are discussed.

###  II-A P2P Technologies

P2P technology, predominantly employed for hardware-level redundancy,
distributes tasks across peer nodes [3], aiming to obviate reliance on
centralized nodes [4]. These nodes, which can function as servers or clients
[5], ensure continuity of functionality when one node falters [6]. P2P
technology also facilitates load distribution and resource sharing [7], yet
the current approach pertains to hardware-level peer-to-peer, with
corresponding software retaining centralized features. For instance, a
centralized software may coordinate others (e.g., a task scheduler in grid
computing) or software instances may feature identical or similar binary codes
(e.g., BitTorrent [15]).

P2P research centers on network structure, efficiency, and overarching
frameworks. (1) Effective P2P network formation is explored through
unstructured and structured networks [16] [17]. (2) Efficiency and scalability
are addressed, with work on effort-based incentives [14]. (3) General
frameworks, such as middlewares, foster P2P software development [18]. P2P
computing, a key application, assigns tasks to multiple servers, where
specific nodes (supernodes) function as intermediaries [19]. Notably, the
decentralized nature of P2P computing is marred by super nodes’
centralization, as their failure can trigger system-wide outages. P2P
technology has also extended to software level applications [8], yet
independent redundancy and software relationship topologies remain unexplored.

An important application of P2P technology is P2P computing, in which tasks
are assigned to multiple servers to execute computations that require a large
amount of resources. During this process, specific nodes (supernodes) act as
intermediaries between users and the task-running server [19]. The super node
has the characteristics of centralization: because if it fails, the whole
system will fail. P2P computing belongs to grid computing. Grid computing is a
kind of distributed computing, which has a center to schedule tasks and
collect final results[20].

With the development of P2P technology, the P2P method at the software level
is proposed. Work[8] proposes P2P software in the blockchain environment. This
work aims to achieve a fully decentralized application model, that is, P2P
software on P2P hardware, and how to achieve consistency between P2P software.
However, it fails to address the issue of independent redundancy among
software, and does not delve into the relationship topology between different
software.

###  II-B N-version Programming

N-Version Programming (NVP) is a software engineering technique aimed at
enhancing software reliability and fault tolerance. NVP involves creating
multiple independent versions of the same software system using varied
methods, algorithms, or compilers. These versions should yield identical
outputs for a given input under normal conditions, enabling error detection
and mitigation through output comparison [9] [10].

NVP and the P2P model represent distinct approaches to bolstering software
reliability and fault tolerance. (1) NVP encompasses multiple independently
developed software versions, aiming to detect errors via output differences.
However, NVP is constrained by a fixed number of versions, limiting
adaptability and scalability in dynamic environments, and introducing
complexities associated with consensus mechanisms and common-mode errors. (2)
In contrast, the P2P model emphasizes high availability through different
software units executing tasks via diverse paths, forming a network topology
with redundancy. Unlike NVP, the P2P model permits flexible addition or
removal of software, enhancing adaptability to changing requirements. The
decentralized execution and failover mechanisms in the P2P model differentiate
it from NVP’s error detection via output comparison.

###  II-C Other Methods to Achieve High Availability

Load balancing techniques, such as Static Load Balancing (SLB) and Dynamic
Load Balancing (DLB), distribute tasks among servers to prevent overloading
[11] [12]. Both rely on a balancing server, which if compromised, can lead to
system failure, and task execution servers typically feature identical
binaries, potentially introducing common errors.

Disaster Recovery (DA) focuses on data storage resilience during natural
disasters [13]. DA entails storing data copies in different locations,
restoring data from unaffected sites when damage occurs. In contrast, the P2P
model concentrates on proactive redundancy through independent software units
with diverse paths, ensuring high availability and fault tolerance. DA
primarily centers on post-event data recovery, while the P2P model emphasizes
distributed redundancy and failover mechanisms.

In summary, while P2P technology, N-version programming and other methods
offer valuable insights into enhancing software reliability and availability,
the proposed P2P software model introduces a unique approach by focusing on
independent redundancy at the software level, facilitating dynamic task
execution through varied paths.

##  III Peer-to-Peer Software Model (P2P Model)

###  III-A Motivation

In a system, both hardware and software components are vulnerable to failures
that can lead to system outages. While redundant hardware is often used to
address hardware failures, a centralized scheduling mechanism might be
necessary. Peer-to-peer (P2P) technology offers an alternative approach to
achieving redundancy and reliability in such systems. However, the
conventional P2P mechanism operates at the hardware level.

Our proposed P2P model extends the concept of P2P from hardware to software.
In this model, software peers can seamlessly redistribute processing tasks,
allowing for swift transitions in the event of software failures. To achieve
this, two requirements must be met:

(1) Static Independence Requirement ($REQ_{1}$): Each software has at least
one candidate software to be replaced, and the candidate software should be
independent of each other.

(2) Dynamic Independence Requirement ($REQ_{2}$): Centralized control of
processing is avoided in the P2P model due to two crucial reasons: (2a) A
failure in the centralized software could lead to a system-wide breakdown, and
(2b) the necessity for software replaceability, as no software can be
guaranteed to be failure-free. To address these concerns, the model emphasizes
the importance of software equality, allowing each piece of software to be
considered a peer, promoting a more balanced and robust architecture.

###  III-B P2P Software

To fulfill $REQ_{1}$ and $REQ_{2}$, a system should consist of multiple
independent softwares capable of redistributing processing tasks seamlessly.
This ensures that individual software failures don’t disrupt the entire
system. This concept is encapsulated in the term P2P software, where a set of
autonomous softwares collaboratively complete tasks without central
coordination. Each individual software in this framework is referred to as a
P2P software or a P2P software peer.

The introduction of P2P software necessitates a shift in related terminology.
An P2P system or application now comprises multiple software peers that
collectively execute tasks. Software peers can be grouped, and each group can
independently complete tasks. Thus, a P2P system or application is not a
single software, but an set of softwares.

A formal description of a P2P application includes the notation
$task.completeBy(soft_{a},soft_{b},...)$, indicating that task $task$ can be
executed by software peers ($soft_{a}$, $soft_{b}$,…). Assuming a P2P
application $P2PAPP$ aims to complete task $task$, it consists of P2P software
peers ranging from $soft_{1}$ to $soft_{n}$, as shown in (1). An P2P
application must satisfy the requirements defined in formulas (2), (3), and
(4). These requirements ensure that the software set can be divided into
independent groups ($P2PAPP_{1}$, $P2PAPP_{2}$, …) capable of completing the
task independently.

$P2PAPP=\\{soft_{1},...,soft_{i},...,soft_{n}\\}$ (1)

$P2PAPP=P2PAPP_{1}\cup P2PAPP_{.}..\cup P2PAPP_{m}$ (2)

$\forall P2PAPP_{m},P2PAPP_{n}\rightarrow\ \ P2PAPP_{m}\cap
P2PAPP_{n}=\emptyset$ (3)

$\forall P2PAPP_{i}\rightarrow\ \ task.completeBy(P2PAPP_{i})$ (4)

####  III-B1 Working Path

Each group in (2) can complete the target task, which can be regarded as a
path in task processing. A working path represents the sequence of software
peers from the initiating terminal to the final processing software for
completing a task. An example is shown in Figure 1. A terminal can choose any
one of the working paths to complete the task. If a software in one working
path fails, task processing can be switched to other working paths.

The number of nodes in the working path corresponds to the number of software
in the corresponding group ($P2PAPP_{i}$). If a single software can complete
the job, the working path contains only two nodes - the terminal and the
processing software. However, in some cases, a working path may consist of
several software peers that cooperate to accomplish a task, resulting in more
than two nodes in the working path.

Figure 1: Working path example. The red path and the blue path are two
different working paths.

In order to support task switching to run on other paths, the target task
should be repeatable task, that is, a task that can be run multiple times.
Since we cannot assume that the task will succeed every time, repeatable
execution is necessary if the task is to be allowed to retry on failure. In
order to identify the same task when it can be executed repeatedly, each task
contains a unique identifier, $id$, as shown in (5). Meanwhile, repeated
execution will also generate multiple results, and the results also contain
the identifier of the corresponding task, as shown in (6).

$task:id,...$ (5)

$Result_{task}:id,...$ (6)

####  III-B2 Function Layers

If a working path consists of multiple software peers, each software peer is
one layer, and we call it a functional layer. The layer division of each
working path may be the same or different. Several paths having the same layer
means that the corresponding layers have the same interface, including input
and output interfaces. If some software has the same layer division, they form
a software pool. These software peers can be candidates for each other, and
task processing can switch between them. As these software peers are
independent, the switching may have more chances to be completed successfully.

Figure 2: Different layers of P2P software. Layers d and e are normal layers
because they have the same input and output interfaces. Layer c is an enhanced
layer because $soft_{1}$ and $soft_{2}$ can be combined to make the input
interface of $soft_{1}$ and the output of $soft_{2}$ the same as that of
$soft_{5}$. And layer b is a virtual layer, because $soft_{8}$ has no
corresponding input and output interfaces, but they can have the same
processing function.

Functional layers can be classified into three types: normal, enhanced, and
virtual layers. If working paths have the same layer division, the
corresponding layer is called a normal layer. For example, $soft_{3}$ and
$soft_{6}$ in Figure 2 form a normal layer (layer d). In addition to the
normal layer division, there are two other layers, the enhanced layer and the
virtual layer.

Enhanced layer. If some softwares on one path can be combined to have the same
interface as software on the other path, they can be considered a layer,
called an enhanced layer. In Figure 2 layer c is an enhanced layer because
$soft_{1}$ and $soft_{2}$ can be combined to have the same input and output as
$soft_{5}$.

Virtual layer. Virtual layers encompass software components with identical
processing functions, yet lack a shared interface across distinct processing
paths. However, from a logical standpoint, these virtual layers exhibit a
uniform interface. In Figure 2, layer b is a virtual layer because $soft_{8}$
does not have input and output interfaces corresponding to $soft_{1}$ or
$soft_{5}$, but they can have the same processing functions.

Different layer types affect the amount of software involved when switching
from one path to another. For comparison, we introduce switch path. A switch
path is a path from faulty software to software that can retry. The length of
the switch path $len_{switch}$ is the amount of software along the switch
path. The switching process consists of two steps.

(1) When a software peer fails, the task processing returns to the upper layer
until there is a software peer that can continue to execute: the software peer
has the same function and is not a failed software peer. The path involved in
this step is called the back path.

(2) In the second step, the task switches to the new software peer to continue
processing. The path to switch to new software peer is called the forward
path.

Figure 3 shows the switching paths for different layers. Correspondingly,
$len_{switch}$ contains the length of two steps, $len_{back}$ (the length of
the back path) and $len_{forward}$ (the length of the forward path), as shown
in (7).

$len_{switch}=len_{back}+len_{forward}$ (7)

Now, we begin to analyze the switch paths of these three types of layers. The
corresponding switch path is shown in Figure 3. The top of Figure 3 (normal
layer) shows the switch path of the normal layer. $len_{switch}$ is three
because three pieces of software are involved, i.e. processing goes from
$soft\\_1$ back to $soft\\_3$ and then switches to $soft\\_2$.

The switch path of the enhanced layer is shown in the middle part of Figure 3,
where $len_{switch}$ is 4. In general, the $len_{switch}$ of an enhanced layer
is $n$ \+ 2, where $n$ is the number of combined software aligned with other
software. In Figure 3, two software ($soft\\_1$ and $soft\\_2$) are combined
to align with $soft\\_3$, so $n$ is 2.

The switch path of the virtual layer is shown in the lower part of Figure 3,
and the minimum value of $len_{switch}$ for this figure is 5. Similarly,
$len_{switch}$ is $k$+$l$+3, where $k$ and $l$ are the number of software in
the ellipsis in the figure. The value of $k$ and $l$ is not less than 1,
because there is at least one software under the corresponding path.

Figure 3: Switch path of different layers. The dotted arrow in purple color is
the switch path.

####  III-B3 P2P Processing Protocol Between Layers

P2P software peers interact through protocols between layers. A new P2P
software peer follows the same protocol to interact with others when joining a
working path. This protocol, known as the P2P Processing Protocol, enables
seamless task switching and interaction between software peers.

The protocol is intended for use between software peers and does not
necessitate a global protocol or the involvement of any centralized or
individual software, with the aim of reducing dependence on centralized
software. This type of agreement is called as a P2P agreement.

If one software peer handles the subsequent task of another software peer, the
former is called target software or target software peer and the latter is
called source software or source software peer. The process is that the source
software peer sends the processed task to the target software peer for further
processing. An example is shown in Figure 4. If the source software peer is in
layer $m$, its target software peer is in layer $n$, where $n>m$.

Figure 4: An example of source and target software peers

The task processing result should be returned to the preceding software (a
source software peer or a terminal). After the target software peer finishes
processing the task, it returns the processing result to the source software
peer. This result is called a return handle. When the final task processing is
completed, the final processing software peer returns the entire processing
path to the terminal, called a return path. The terminal can use the return
path to query the processing results in any software peer on the working path.

Here we discuss the terminal. The terminal is a system that sends task
requests to P2P applications, which can be mobile phones or servers. The path
to the P2P layer is configured in the terminal. After final processing, the
return path is sent back to the terminal.

###  III-C Working Procedure

The processing flow of P2P software is from the terminal to the final
processing software. Assume that the terminal is $t_{k}$, and there are $n$
software peers (named from $soft^{1}_{1}$ to $soft^{1}_{n}$) in layer 1
($layer_{1}$). The process is divided into the following three stages.

(1) Initial stage. At the beginning, $t_{k}$ chooses a software peer in
$layer_{1}$ (suppose $soft^{1}_{i}$). If $soft^{1}_{i}$ does not respond
within the specified time, it is considered down, and $t_{k}$ will choose
another software peer from $layer_{1}$ until (1a) an available software
peer($soft^{1}_{j}$) is found or ( 1b) all software peers in $layer_{1}$ do
not work. If (1b) it will return an error return handle to $t_{k}$, which
means that none of the peer to peer software cannot handle the task
successfully and more P2P software peers required.

(2) Middle choice stage. Assuming that the current process is processed in
software $soft^{m}_{n}$ at layer $layer_{m}$, the task processing will be
passed from $layer_{m}$ to $layer_{m+1}$. There are three possible outcomes.
(2a) If an available software peer ($soft^{m+1}_{l}$) is found, processing is
passed to $layer_{m+1}$. (2b) If no software peer in $layer_{m+1}$ is found,
$soft^{m}_{n}$ will notify the source software peer in $layer_{m-1}$ and
retries in $layer_{m-1}$. (2c) If $soft^{m}_{n}$ becomes unresponsive due to a
crash, its source software peer detects this and retries.

(3) Completion stage. A task is considered complete when the processing of the
last layer is complete. In this case, the return path is given to terminal
$t_{k}$. If the feedback does not reach the terminal $t_{k}$ within the
maximum time ($t^{require}_{max}$), the terminal must reissue the request,
even if the process has been completed at the final layer.

###  III-D Key Measurements

In this section, we describe two key measurements of P2P software: the
successful probability and the task time. (1)The goal of P2P software is to
increase the probability of task completion, so the first measurement is the
degree of success of task completion, the successful probability. (2)
Different paths will affect the switching mechanism when a P2P software peer
fails, resulting in different completion times. In order to measure the
completion time, we introduce another measurement from the perspective of
time, the average time for task completion or failure, named as the task time.

####  III-D1 Successful Probability

The successful probability is the probability of task completion, denoted as
$P_{success}$. Since there are different paths to complete the task, the
successful probability is the union of the success probabilities of all paths,
as shown in (8).

$\begin{array}[]{ll}P_{success}=P_{success}(P_{path_{1}}\cup...\cup
P_{path_{i}}\cup...\cup P_{path_{n}})=\\\ \ \ \ \ \ \ \ \
\sum_{i=1}^{n}{(P_{path_{i}})}\\\ \ \ \ \ \ \ \ \
-\sum_{i=1}^{n-1}{(P_{path_{i}}P_{path_{i+1}})}\\\ \ \ \ \ \ \ \ \
+\sum_{i=1}^{n-2}{(P_{path_{i}}P_{path_{i+1}}P_{path_{i+2}})}\\\ \ \ \ \ \ \ \
\
-\sum_{i=1}^{n-3}{(P_{path_{i}}P_{path_{i+1}}P_{path_{i+3}}P_{path_{i+4}})}\\\
\ \ \ \ \ \ \ \ +...\\\ \ \ \ \ \ \ \ \ -...\end{array}$ (8)

From (8), we can see that $P_{success}$ increases when the number of paths
increases. This can be understood as when some paths fail, there are more
alternative independent paths available to execute tasks.

Now we analyze the successful probability for different types of layers,
normal, enhanced and visible layers. For simplicity, we only analyze the case
where there are only two paths, and where each software peer has the same
successful probability.

In the case of normal layers, the switch path can be switched at the same
layer, as illustrated in Figure 5. Therefore, $P_{success}$ is shown in (9).

$P_{success}=P_{path_{1}}\cup P_{path_{2}}$ (9)

Figure 5: Normal layer. The red line indicates the same protocol (the same
below).

The successful probability of enhanced layers is often smaller than that of
the normal layers. An example is shown in Figure 6, where the upper layer
working path has multiple software peers to align with the lower layer working
path. The corresponding $P_{success}$ is shown in (10). As can be seen from
(10), the corresponding path has a smaller successful probability, since all
software peers along that path must succeed for the task to complete.
Therefore, it results in an overall smaller successful probability.

$P_{success}=(P_{soft_{k}}\cap...\cap P_{soft_{l}})\cup P_{soft_{m}}$ (10)

Figure 6: Enhanced layer.

The virtual layer is shown in Figure 7. The corresponding successful
probability is shown in (11). There are more than one software peer involved
in the back and forward paths, which results in the lowest successful
probability of the three.

$P_{success}=(P_{soft_{k}}\cap...\cap
P_{soft_{l}})\cup(P_{soft_{m}}\cap...\cap P_{soft_{n}})$ (11)

Figure 7: Visual layers.

####  III-D2 Task time

Task time refers to the average duration required to process a given task,
from the moment it is sent by the terminal to the point at which task
processing is completed. The completion of a task means that either the task
has been successfully processed, or all available paths have been attempted
and deemed unsuccessful.

Task time has an impact on the wait time required for the terminal, as per the
P2P software model. Specifically, the terminal will either re-issue a task if
a path fails, or record the return path if it succeeds. In general, longer
task times require longer wait times for the terminal.

Now, we begin to analyze the maximum waiting time for a task to complete. The
task time represents the average time required to complete a task. Some tasks
may take longer than the task time to complete. Therefore, it is recommended
for a terminal to wait for a sufficient amount of time before timing out. We
set a maximum waiting time in each layer (denoted as $t^{i}_{max}$ for layer
$i$). The sum $t^{total}_{max}$ for each layer is shown in (12).

$t^{total}_{max}=\sum_{1}^{n}{t^{i}_{max}}$ (12)

, where $n$ is the total number of layers.

When the number of layers increases, $t^{total}_{max}$ may become larger. To
reduce the impact of unknown latencies, we introduce a cache layer, named as
the P2P cache layer. An P2P cache layer is the layer that caches task
requests, and gives the return handle to the terminal when the target task
completes. When tasks are cached, terminal retries can be done by the caching
layer. User terminals can even be turned off to save power. However, the
terminal should send tasks to multiple software peers in the caching layer to
avoid failure of one cache software peer.

When caching layers are introduced, the waiting time of a terminal,
$t^{total}_{waiting}$, is displayed in (13), where $k$ is the layer number of
the caching layer. From (13), we can see that when $k$ is smaller (closer to
the terminal), $t^{total}_{waiting}$ is smaller. Therefore, the caching layer
is usually positioned in layer 1, and the terminal only needs to wait for the
request to be sent to the P2P cache layer.

$t^{total}_{waiting}=\sum_{1}^{k}{t^{i}_{max}}$ (13)

, where $k$ is the layer number of the cache layer and $k$ <$n$.

##  IV Topology

A working path is a linear structure, while multiple working paths may form a
network structure, which we call the topology of a P2P application. Topology
specifies the interaction relationship of P2P software peers.

To depict the network formed by working paths, a topology graph is employed.
The topology graph comprises P2P software peers as vertices and the
interaction relationships between P2P software peers as edges. The edges are
directional, originating from the source software peer and terminating at the
target software peer. Correspondingly, a working path is the path (in
topology) from a user request to the final processing software, representing
the entire processing of a task.

###  IV-A Separate and Coupled Paths

Regarding whether the paths have the same software peer, the paths can be
divided into separate paths and coupled paths. Separate paths are paths that
have no common vertices, it is also called basic path. Meanwhile, paths with
common vertices are called coupled paths. Figure 8 shows separated and coupled
paths.

Figure 8: Separate path and coupled path. In the coupled path, there are two
vertexes (vertex a and b in red) which are in path 1 and path 2; while in the
separate paths, there is no such vertexes.

Both separate and coupled paths can be working paths because they contain
enough software peers required to complete a task. Therefore, the number of
working paths is the sum of separate paths and coupled paths. We use a
variable $Path_{task}$ to represent the collection of all working paths, as
shown in (14).

$Path_{task}=\\{path_{wk_{1}},...,path_{wk_{n}}\\}$ (14)

, where $path_{wk_{i}}$ is a separate or coupled path.

If each software peer on a working path has an equal successful probability,
then a separate path will have a higher successful probability than a coupled
one. Assume that there are two paths with success probabilities $p1$ and $p2$,
and the final successful probability is shown in (15). The value of $p1*p2$ is
0 in the separate path, because they have no common software peer, so the
successful probability of the separate path is greater.

$p_{success}=p1+p2-p1*p2$ (15)

###  IV-B Topology Types

It’s not always possible to optimize both the successful probability and task
time simultaneously. If we want to increase the successful probability, we may
need to add more working paths. However, more working paths can also lead to
more switching, which increases the task time. Therefore, different topologies
offer the opportunity to choose a trade-off between these two measurements.

####  IV-B1 Full Connection

Full connection is a P2P topology, where each software peer on the previous
layer connects to all software peers on the next layer. In the corresponding
topological graph, all possible vertices within the same layer are connected
and no more edges can be added, as shown in Figure 9.

Figure 9: Example of full connection. All possible edges within the same layer
are connected, no more edges can be added.

Correspondingly, the successful probability is maximized for full connections,
since all possible retry paths can be used. The task can only fail if there
are no available paths from the source software peer to the target software
peers, as in (16).

$\forall path\in Path_{task},path\in Path_{full}$ (16)

, where $Path_{full}$ is all paths in the full connection.

On the other hand, in the full connection, the task time is maximal. In the
worst case, all possible paths to the next layer will be retried, as shown in
(17).

$time^{retry\\_full}_{max}=\sum^{path_{i}\in
Path_{full}}{time^{retry}_{path_{i}}}$ (17)

, where $time^{retry\\_full}_{max}$ is the maximum task time of full
connection, and $time^{retry}_{path_{i}}$ is the task time taken by
$path_{i}$.

####  IV-B2 Minimum Connection

In some cases, it’s necessary to limit the task time, while ensuring a high
successful probability. We can remove some paths to reduce retries on working
paths. Meanwhile, a software peer should connect to at least $m$ software
peers to ensure that $P_{success}\textgreater\delta$. Although, the minimum
connection does not cover all possible paths, it guarantees a successful
probability greater than $\delta$.

$\begin{array}[]{l}Path_{minimum}\subset Path_{task}\\\
P_{success}(Path_{minimum})>\delta\end{array}$ (18)

, where $Path_{minimum}$ is the set of all paths in the minimum connection.

From (18), we see that $P_{success}(Path_{minimum})$ is less than
$P_{success}(Path_{full})$ because $Path_{minimum}\in Path_{full}$ .

The task time of the minimum connection is the sum of the attempt times of its
paths, as shown in (19), which is less than the task time of the full
connection, as shown in (17).

$time^{retry\\_minimum}_{max}=\sum^{path_{i}\in
Path_{minimum}}{time^{retry}_{path_{i}}}$ (19)

, where $time^{retry\\_minimum}_{max}$ is the maximum task time of the minimum
connection, and $time^{retry}_{path_{i}}$ is the task time occupied by
$path_{i}$.

Comparing the minimum connection and the full connection, there is a trade off
between them: although the successful probability of the minimum connection is
smaller, its maximum task time is smaller.

###  IV-C Add New Software Peer to Topology

When a new software peer is added, its successful probability is uncertain,
although it may have been verified elsewhere. The successful probability in
the new environment should be measured by the actual processing results
thereafter.

Since a new software peer does not guarantee a successful probability, the
software peer should not be relied upon to complete tasks. Otherwise, there
may be situations where the introduction of new software fails (as in
COVID-19).

Therefore, the method of double sending is used. The double sending method is
to send the request to multiple target software peers. In this case, the
request is sent to a known software peer and another to the new software peer.
Tasks are processed in parallel. If a task is successfully processed by the
new software within a certain amount of time, the software’s successful
probability increases; otherwise, the successful probability decreases. This
paper proposes to keep the successful probability software in its source
software because (1) this eliminates a centralized software to record the
successful probability, and (2) it is the source software that selects the
target software.

When the successful probability of a new software peer reaches a certain
value, the double sending can no longer be used. And double sending can also
be used to save task time. If a task fails to be processed in one working
path, there is still another working path, which saves the corresponding retry
and waiting time.

##  V Verification

###  V-A Test Environment

The test environment are described in three aspects: the P2P software, the
topology formation, and the collection of corresponding measurements.

The whole system is composed of different P2P software peers, each of which is
assigned an independent successful probability. In this verification, each P2P
software is a web server, obtaining and processing task requests from other
P2P software peers. After a P2P software peer finishes processing a task, the
P2P software peer further transfers the task to its target software peer by
calling the corresponding web interface.

The simulation of being down is as follows. When a P2P software peer gets a
task, it generates a random number in a certain range (0 to N, N is
sys.maxsize in python, 9223372036854775807 in the verification system). If it
is less than ($1-p$)*N , the software peer is set to hang and simulated by
sleeping infinitely. Otherwise, the task processing succeeds: (1) the
signature of the processing software is added to the task’s data field, and
(2) to simulate the processing time of the task, it sleeps for a few seconds.
If the source software does not get the return handle within a certain period
of time, it is considered that the target is down.

The P2P topology information is configured into each software peer, without
the need for a centralized software to maintain such information. One of the
important information is the interface parameters of the target software peer.
This information is configured in its source software. When the target
software is down, the source software can select another target software
through this information.

The result of the task is judged as follows. Judgment of task success: the
final processing software completes the processing and passes the
corresponding return handle to the terminal (because the cache layer is not
used during verification, the return handle should be returned to the
terminal). Judgment of task failure: all paths have been tried and task
processing failed or no return handle has been provided to the terminal layer.

The corresponding measurements are collected below. For the successful
probability, we use two counters, $counterS$ and $counterF$. When the task
succeeds, $counterS$ is incremented by 1, and when the task fails, $counterF$
is incremented by 1. The successful probability is calculated as:
$p_{success}=counterS/(counterS+counterF)$. For task time, two related time
indicators are recorded: (1) the start time is recorded when the terminal
sends the task; (2) the final time is recorded when the task fails or
succeeds. The task time is the difference between the end time and the start
time.

###  V-B Successful Probability

In this section, we try to verify the factors that affect the successful
probability, including the impact of different paths, the impact of coupling,
and the impact of division granularity.

####  V-B1 Impact of Different Path

To form the different paths, we used several topologies: different numbers of
basic paths and different ways of connecting them. (1) The types of basic
paths are 2-basic paths, 3-basic paths, and 4-basic paths. (2) Connections
between different layers include: separate paths, fully connected layers 2
(layer 2 full), fully connected layers 2 and 3 (layer 2, 3 full), and fully
connected layers 2, 3, and 4 (ayer 2, 3 and 4 full). Separate paths mean that
all basic paths are independent, i.e. software in one basic path is not
connected to software in other paths. A fully connected layer means that every
piece of software in the previous layer is connected to all software in that
layer.

After combining the basic paths and connection methods, there are 12 test
scenarios in total. Each scenario was executed 1000 times. The result is shown
in Figure 10, which shows two interesting points. (1) When the number of basic
paths increases, the successful probability increases. Taking layer 2 full as
an example, when the number of basic paths increases from 2 basic paths to 4
basic paths, the successful probabilities are 0.52, 0.70, and 0.81,
respectively. (2) When the number of fully connected layers increases, the
successful probability increases. Considering 3 basic scenarios, the
successful probabilities are 0.56, 0.70, 0.83, 0.90 seconds respectively. This
suggests that if we want to increase the successful probability, we either
increase the number of basic paths or the number of full connections.

Figure 10: The impact of different path number.

####  V-B2 Impact of Coupling Path

We choose two basic paths with four layers for verification, and there are
four cases depending on the software used in common, named 0common, 1common,
2common and 3common respectively. The first number in these names indicates
the amount of the same software peer(s) used. For instance, 2common indicates
that these paths have two identical software peers. 0common means that these
paths do not have any identical peers, i.e. they are separate paths. Using
identical software peers creates interdependence between the paths. If there’s
a failure in the commonly used software peer, both paths will fail
simultaneously, i.e. these paths are coupled by the identical software peer.

Each scenario is executed 1000 times and the results are shown in Figure 11.
It can be seen from the figure that the successful probability is the higher
when all paths have no common software (none, separate way), 0.32. The
successful probabilities of the other three cases are lower, 0.299, 0.302,
0.304 respectively. The verification results show that separate paths have a
greater successful probability.

Figure 11: The successful probability affected by coupled path number.  Figure
12: Impact of layer division on the successful probability.  Figure 13: The
task time affected by different path number. Figure 14: The task time affected
by full connection with 4 basic paths.

####  V-B3 Impact of Division Granularity

In order to verify the impact of division granularity on the successful
probability, we designed four types of verification: (1) there is no division
in the basic path, named as 1layer, (2) each basic path is divided into 2
layers, named as 2layer, (3 ) each basic path is divided into 4 layers, named
as 4layer, and (4) each basic path is divided into 8 layers, named as 8layer.

Layer division has the following restrictions.

(1) The connections between the basic paths are fully connected. The
successful probability for the basic path is set to 0.5. The reason is that if
the successful probability of a basic path is set to 0.7, then when all paths
are fully connected, the successful probability will reach 99.1%
($1-(1-0.7)^{4}$), which makes the difference between different verification
scenarios smaller.

(2) The successful probability ($p_{success}^{i}$) of a task is calculated by
the successful probability $p_{success}$ of the basic path. If the basic path
is divided into $n$ layers. Their total successful probability is equal to
$p_{success}$, as shown by (20).

$p_{success}=p_{success}^{1}*p_{success}^{2}*...*p_{success}^{n}$ (20)

, where $p_{success}^{i}$ is the successful probability of the $i$th software
in a basic path. In the verification, the successful probability is the same
for each software, so we get $p_{success}^{i}=\sqrt[n]{p_{success}}$.

Each scenario was tested 1000 times, and the results are shown in Figure 12.
The successful probabilities of layers 1, 2, 4, and 8 are 0.937, 0.992, 0.996,
and 1.0, respectively. The successful probability increases by 0.057 from the
case of no layer division (1layer) to 2 layers (2layer), while the increase
from 2layer to 4layer is only 0.004 because the successful probability is
close to 1.0. This verification shows that more layer divisions increase the
successful probability

###  V-C Task Time

In this section, we want to verify the factors that affect the task time.
There are four sub-verifications, the impact of different paths, the impact of
coupling, the image of division granularity and the impact of double sending.

####  V-C1 Impact of Different Paths

In this verification, we verify the impact of different paths on the task
time, including topologies with different number of paths and different
connection methods. The test scenario is still 12 different basic paths
(2-basic path, 3-basic path, 4-basic path) and different connection methods
(separate, layer 2 full, layer 2 and 3 full, and layer 2 3 and 4 full).

Each scenario was executed 1000 times. The result is shown in Figure 13 and
Figure 14. Figure 13 shows the task time comparison between different numbers
of paths, from which we can see that the task time increases as the number of
basic paths increases. This is because when the number of basic paths
increases, more paths can be retried, resulting in more task time.

Figure 14 shows the task time comparison between different connection methods.
We show the task times for the 4 basic path cases because the other two basic
path cases have similar trends. The task time increases first and then
decreases, which are 5.70, 7.86, 6.92, and 5.20 seconds respectively. The
increase in task time is due to the increase in the number of paths that can
be retried. The subsequent decrease in task time is due to the increased
successful probability: the probability that the software fails at a layer is
only 0.0081 ($(1-0.7)^{4}$), because more paths can be retried. A task can be
executed successfully in this layer without returning to the previous layer.
For example, the case of 2, 3, and 4 fully-connected layers has shorter task
times than the separate path.

####  V-C2 Impact of Coupling

In this part, we verify the impact of software coupling on task timing.
Verification scenarios include scenarios using two paths with four layers
(0common, 1common, 2common, and 3common, similar to the scenarios in section
V-B). Each scenario is tested 1000 times, and we take the average task time,
as shown in 15.

Figure 15: Impact of coupled paths on average task time.

From Figure 15, it can be seen that there is not much difference between these
cases, and the average task time for the cases from 0common to 3common is
3.91, 3.93, 3.85, 3.85 seconds, respectively. The difference between the
maximum and minimum is 0.08 seconds, which is only 2.04% of the average task
time of the maximum (1common).

####  V-C3 Impact of Layer Division Granularity

We still adopt the four verification scenarios in the V-B3 section, aiming to
verify the impact of different layer division granularity on task time. The
verification was carried out 1000 times, and the average task time is shown in
Figure 16. From this figure, we can see that the task time increases by more
than 2 seconds, from 2.26 seconds (2layer case) to 4.28 seconds (4layer case).
This is because there are many paths that need to be retried during task
processing. While the task time from the 4layer case to the 8layer case only
increased by 0.77 seconds, from 4.28 seconds to 5.05 seconds. The reason is
that the successful probability is almost close to 1 at this time (the
successful probability is from 0.996 to 1.0 in Figure 12), so that the task
time does not increase significantly.

Figure 16: Impact of number of coupled paths on task time.

####  V-C4 Double Sending

In this verification, we verified the impact of double sending on task time,
using two scenarios named noDoubleSending and doubleSending respectively. We
adopt a full connection with 4 basic paths and set the successful probability
of each basic path to 0.5. If there are two pieces of software in the
subsequent layer that have not processed a task, the task is sent to the two
subsequent pieces of software for processing. A task is considered successful
if there is one final piece of software that successfully processes the task
and gives the return handle to the terminal. If none of the software can
handle the task, task processing is considered as failed.

The two scenarios are also carried out 1000 times, and the result is shown in
Figure 17. As can be seen from the figure, the noDoubleSending task takes
almost twice as long as the doubleSending method. Their average task times
were 9.24 and 4.15 seconds, respectively.

This verification shows that double sending can save a lot of time (maybe only
50% of the original task time). But it also has some disadvantages: in the
double sending method, a task may be successfully processed twice, This can be
a waste of computing resources.

Figure 17: Average task time affected by double sending.

##  VI Conclusion

This paper has presented a novel software in Peer-to-Peer (P2P) model designed
to enhance high availability at the software level, addressing the critical
gap in existing P2P architectures. By emphasizing the decentralized nature of
software entities and advocating for independent, autonomous operation, the
proposed model offers a promising solution for achieving robust software-level
high availability. Moreover, the model obviates the need for software with
central functions, such as task scheduling or dispatching. Through the
establishment of a collaborative network topology with multiple autonomous
processing paths, the model ensures seamless task transitions and continuous
operation, even in the face of software-related disruptions or failures.

The comprehensive analysis and validation of the proposed P2P software model
have demonstrated its effectiveness in improving the probabilities of
successful task processing while maintaining high availability. By overcoming
the constraints of conventional redundancy methods and centralized software
coordination, the model provides an adaptive and scalable framework that
enhances the resilience and adaptability of P2P networks. The flexibility
offered by the software peers in joining or leaving the network without
relying on a centralized software infrastructure marks a advancement in the
field, promising a more robust and flexible architecture for future system
designs.

## References

  * [1] Vayghan L A, Saied M A, Toeroe M, et al. Microservice based architecture: Towards high-availability for stateful applications with kubernetes[C]//2019 IEEE 19th international conference on software quality, reliability and security (QRS). IEEE, 2019: 176-185.
  * [2] Li C, Song M, Zhang M, et al. Effective replica management for improving reliability and availability in edge-cloud computing environment[J]. Journal of Parallel and Distributed Computing, 2020, 143: 107-128.
  * [3] Tselios C, Birkos K, Papageorgiou C, et al. Evolution of P2PSIP Architectures, Components and Security Analysis[M]//Future Internet Services and Service Architectures. River Publishers, 2022: 119-138.
  * [4] Marzal S, Salas R, González-Medina R, et al. Current challenges and future trends in the field of communication architectures for microgrids[J]. Renewable and Sustainable Energy Reviews, 2018, 82: 3610-3622.
  * [5] Huynh T K, Le H D, Nguyen S V, et al. Applying peer-to-peer networks for decentralized customer-to-customer ecommerce model[C]//International Conference on Future Data and Security Engineering. Springer, Singapore, 2020: 21-34.
  * [6] Bauwens M, Kostakis V, Pazaitis A. Peer to peer[M]. University of Westminster Press, 2019.
  * [7] Singh V P, Vijay T, Angmo R, et al. Secure Communication in Peer-to-Peer Network Based on Trust-Based Model[M]//Cyber Security in Intelligent Computing and Communications. Springer, Singapore, 2022: 157-170.
  * [8] Su H, Guo B, Lu J, et al. Fully Decentralized Application Model by Peer to Peer Smart Contract of Blockchain[J]. 2021.
  * [9] Levitin G, Xing L, Xiang Y. Optimization of time constrained N-version programming service components with competing task execution and version corruption processes[J]. Reliability Engineering & System Safety, 2020, 193: 106666.
  * [10] Girdhar V, Al-Masri E. N-Version Programming for Enhancing Fault Tolerance in Fog-based IoT Systems[C]//2020 6th International Conference on Science in Information Technology (ICSITech). IEEE, 2020: 109-114.
  * [11] Shafiq D A, Jhanjhi N Z, Abdullah A. Load balancing techniques in cloud computing environment: A review[J]. Journal of King Saud University-Computer and Information Sciences, 2021.
  * [12] Mishra S K, Sahoo B, Parida P P. Load balancing in cloud computing: a big picture[J]. Journal of King Saud University-Computer and Information Sciences, 2020, 32(2): 149-158.
  * [13] Mendonca J, Andrade E, Endo P T, et al. Disaster recovery solutions for IT systems: A Systematic mapping study[J]. Journal of Systems and Software, 2019, 149: 511-530.
  * [14] Rahman R, Meulpolder M, Hales D, et al. Improving efficiency and fairness in p2p systems with effortbased incentives[C]//2010 IEEE International Conference on Communications. IEEE, 2010: 1-5.
  * [15] Söderberg E, Råhlén J. An analysis of decentralized peer-to-peer file sharing performance: An overview of how different parameters affect the average download time in a BitTorrent-like network[J]. 2021.
  * [16] Stutzbach D, Rejaie R, Sen S. Characterizing unstructured overlay topologies in modern P2P file-sharing systems[J]. IEEE/ACM Transactions on Networking, 2008, 16(2): 267-280.
  * [17] Crainiceanu A, Linga P, Machanavajjhala A, et al. Pring: an efficient and robust p2p range index structure[C]//Proceedings of the 2007 ACM SIGMOD international conference on Management of data. 2007: 223-234.
  * [18] Shudo K, Tanaka Y, Sekiguchi S. P3: P2P-based middleware enabling transfer and aggregation of computational resources[C]//CCGrid 2005. IEEE International Symposium on Cluster Computing and the Grid, 2005. IEEE, 2005, 1: 259-266.
  * [19] J. Mishra and S. Ahuja, ”P2PCompute: A Peer-to-peer computing system,” 2007 International Symposium on Collaborative Technologies and Systems, 2007, pp. 169-176
  * [20] Zhang S, Chen X, Zhang S, et al. The comparison between cloud computing and grid computing[C]//2010 International Conference on Computer Application and System Modeling (ICCASM 2010). IEEE, 2010, 11: V11-72-V11-75.
  * [21] Su H, Guo B, Shen Y, et al. A Solution for State Conflicts of Smart Contract in Interaction with Non-blockchain[C]//IEEE INFOCOM 2020-IEEE Conference on Computer Communications Workshops (INFOCOM WKSHPS). IEEE, 2020: 382-387.


# Charges, conserved quantities and fluxes in de Sitter spacetime

Aaron Poole, Kostas Skenderis and Marika Taylor  STAG Research Centre &
Mathematical Sciences, Highfield, University of Southampton, SO17 1BJ
Southampton, UK

###### Abstract

We discuss the definition of conserved quantities in asymptotically locally de
Sitter spacetimes. One may define an analogue of holographic charges at future
and past infinity and at other Cauchy surfaces $I_{t}$ as integrals over the
intersection of timelike surfaces $C$ and the Cauchy surface $I_{t}$. In
general, the charges $Q^{t}$ defined on the Cauchy surface $I_{t}$ depend on
$C$, but if gravitational flux is absent the charges are independent of $C$.
On the other hand, if there is a net gravitational flux entering or leaving
the spacetime region bounded by $C_{1},C_{2}$ and two Cauchy surfaces then
$\Delta Q^{t}(C_{1},C_{2})=Q^{t}(C_{1})-Q^{t}(C_{2})$ changes by the same
amount.

## Introduction

Isolated systems with no dynamical gravity have conserved energy and momentum
originating from translational invariance. These charges may be obtained from
a conserved local energy-momentum tensor via appropriate integrals over a
Cauchy surface. If a system is open there may be flux of energy and momentum
through its boundary, which is again encoded by the energy-momentum tensor. A
prime example of flux is that of electromagnetic radiation originating from a
localised source and propagating out to infinity. When gravity is dynamical
the corresponding symmetries are local and as such the corresponding charges
would be zero if there are no boundaries or asymptotic regions.

The study of (conserved) charges in gravitational theories and of
gravitational radiation has a long history going back to (at least) [1, 2, 3,
4, 5]. Diffeomorphism invariance implies that the charges should be defined by
surface integrals at infinity, but due to the infinite volume of spacetime any
such definition requires a subtraction, potentially making the charges
ambiguous. Most of the initial work concerned asymptotically flat gravity, and
in this context charges were defined relative to flat spacetime. With such
asymptotics one may also define outgoing gravitational radiation through null
infinity, as illustrated in Fig. 1. In the presence of a cosmological constant
the asymptotic structure changes and new issues arise.

Figure 1: Penrose diagram illustrating the flux of gravitational radiation
through null infinity, $\mathscr{I}^{+}$, in an asymptotically flat spacetime.
The hypersurfaces $C_{1},C_{2}$ are taken to be null (“instants of retarded
time”) although they could also have been chosen to be spacelike.

With negative cosmological constant, the anti-de Sitter/Conformal Field Theory
(AdS/CFT) correspondence suggests that one should be able to formulate the
problem in exactly the same way as when gravity is non-dynamical. Indeed, one
can show that such spacetimes are always equipped with a covariantly conserved
symmetric tensor which may be used to construct conserved charges. This tensor
is identified with the (expectation value of the) energy-momentum tensor of
the dual CFT in the AdS/CFT correspondence [6]. Asymptotically locally AdS
(AlAdS) spacetimes have a timelike conformal boundary and an associated
boundary conformal structure. In the neighborhood of the conformal boundary
the metric admits the following Fefferman-Graham form [7],

$ds^{2}=\frac{l^{2}_{AdS}}{\rho^{2}}\left(d\rho^{2}+g_{ab}(\rho,x)dx^{a}dx^{b}\right)$
(1)

where $l_{AdS}$ is the curvature radius and in four dimensions:

$g_{ab}=g_{(0)ab}+\rho^{2}g_{(2)ab}+\rho^{3}g_{(3)ab}+\cdots$ (2)

Throughout this Letter for concreteness we specialise to four dimensions. Most
of the discussion generalises straightfowardly to other dimensions, modulo
issues associated with the holographic conformal anomaly in odd dimensions
[8]. Here $g_{(0)}$ is the representative of the boundary conformal structure
and the holographic energy momentum tensor is given by

$T_{ab}=\frac{3l_{AdS}}{16\pi G}g_{(3)ab}\,,$ (3)

where $G$ is Newton’s constant. If the boundary conformal structure admits
conformal Killing vectors $\zeta^{a}$ then the energy-momentum tensor may be
used to construct associated conserved charges via a surface integral over a
spacelike surface at infinity,

$Q_{\xi}=\int_{\partial C}ds_{a}T^{a}_{b}\zeta^{b},$ (4)

where $\partial C$ is the intersection of the bulk spacelike surface $C$ with
the conformal boundary. It was shown in [9] using Noether’s method and
covariant phase space methods that (4) are the bulk gravitational charges.
These charges are well-defined due to the boundary counterterms introduced by
holographic renormalisation [8, 10, 6, 11]. In fact the counterterms are also
required for well-posedness of the variational problem when the boundary
conformal structure is fixed [9].

The purpose of this Letter is to address the analogous issues for spacetimes
with positive cosmological constant. Asymptotically locally de Sitter (AldS)
spacetimes share a number of properties with AlAdS spacetimes but there are
also important differences. The conformal boundary of AldS spacetimes is
spacelike and typically has two causally connected components, one at past
infinity and one at future infinity (in contrast the AdS conformal boundary is
typically connected111See [12] for general results regarding the Euclidean AdS
case.). Near each component the structure of the spacetime is related by
analytic continuation to that of a corresponding AlAdS spacetime [13], with
results analogous to (1), (2), (3) (recovering the asymptotic expansion first
presented in [14]). AldS spacetimes are spatially compact so one cannot define
conserved charges as integrals at spatial infinity. Nevertheless, explicit
solutions (for example the Schwarzschild dS solution) have integration
constants that traditionally are interpreted as the values of conserved
charges (like mass and angular momentum). These charges are associated with
conformal Killing vectors of the conformal structure at future infinity and
may be computed by integrals of the energy momentum tensor at future infinity.
However, they are not conserved in the usual sense, i.e. under time evolution.
Instead these charges are conserved under spatial translations if there is no
gravitational radiation, as we discuss below.

The discussion of gravitational charges in de Sitter spacetimes goes back to
at least [15], and there has been renewed interest in this topic since our
Universe appears to have positive cosmological constant and gravitational
waves have been observed. Recent works include those of Ashtekar et. al. [16,
17, 18, 19, 20, 21] (which builds upon earlier work, [22, 23]) that discuss
charges and radiation for linearised fields on dS, and Chruściel et. al. [24,
25, 26] where different approaches to the computation of energy and linear
fluxes between null cones in dS are considered, see also [27, 28, 29, 30, 31].
A number of other approaches to examining radiative bodies in dS can be found
in [32, 33, 34, 35, 36, 37]. As outlined above, there are many similarities
between dS and AdS and works that use the similarity to define charges and
fluxes include [38, 39, 40, 41, 42, 43, 44, 45, 46].

Our work significantly develops understanding of charges and fluxes in de
Sitter. Earlier works were focussed on asymptotically de Sitter spacetimes but
our analysis holds for the general class of asymptotically locally de Sitter
spacetimes. Restricting to asymptoticially de Sitter does not allow for
gravitational waves propagating to the conformal boundary and therefore misses
important physical effects. In our work divergences associated with the
conformal boundary are treated systematically with holographic renormalisation
i.e. covariant boundary counterterms. This approach leads to unambiguous
results for changes that are intrinsic to the spacetime rather than defined
relative to a reference spacetime and hold for general asymptotically locally
de Sitter spacetimes.

Another key difference with previous works is that we focus on the qualitative
new issues that arise in de Sitter, relative to AdS and flat space. One such
key difference is the observation that there are contributions to charges from
both endpoints of the timelike surfaces used to define the charges. In
previous literature contributions from inner boundaries were often set to be
zero by imposing fall off conditions on fields but we do not need to impose
any such restrictions. We explain that one needs to consider fluxes through
box regions in generic dynamical situations and we give a precise
characterisation of this gravitational flux. In particular, we obtain a
quantity that is conserved under time evolution in the absence of fluxes and
equals the flux when gravitational flux is present.

## Covariant phase space formalism

The main tool we use in our analysis is the covariant phase space [47, 48, 49,
50, 51, 52] (see also the recent works [53, 54] and references therein, and
[55] for an alternative but equivalent formalism). The key object is the
$(d-1)$-form symplectic current ${\bf{\omega}}$. Starting from a
diffeomorphism covariant Lagrangian $d$-form ${\bf{L}}(\psi)$, the symplectic
current is given by

${\bf{\omega}}(\psi,\delta_{1}\psi,\delta_{2}\psi)=\delta_{1}\Theta(\psi,\delta_{2}\psi)-\delta_{2}\Theta(\psi,\delta_{1}\psi)\,,$
(5)

where $\Theta$ is the total derivative in the onshell variation of
${\bf{L}}(\psi)$, $\delta{\bf{L}}=d{\Theta}$ ($\psi$ denotes the metric and
other fields). A crucial property of ${\bf{\omega}}$ is that it is closed
onshell,

$d\omega=0\,.$ (6)

Consider now onshell configurations $\psi$ whose variations $\delta\psi$ are
also onshell. For a diffeomorphism generated by $\xi$ the corresponding
Hamiltonian $H_{\xi}$ is given by

$\delta H_{\xi}=\int_{C}{\bf\omega}(\psi,\delta\psi,{\cal L}_{\xi}\psi)$ (7)

with $C$ a $(d-1)$-dimensional slice, which for many applications is a Cauchy
surface, and ${\cal L}_{\xi}$ is the Lie derivative. Given such a
diffeomorphism we can associate a $(d-1)$-form Noether current, ${\bf
J}(\xi)=\Theta(\psi,{\cal L}_{\xi}\psi)-i_{\xi}{\bf L}$, where $i_{\xi}$ is
the interior product. The current ${\bf J}$ is closed onshell and is thus
locally exact: ${\bf J}(\xi)=\text{d}{\bf Q}(\xi)$ with $(d-2)$-form Noether
charge ${\bf Q}$, the variation of $H_{\xi}$ may be written as

$\delta H_{\xi}=\int_{\partial C}\left(\delta{\bf
Q}(\xi)-i_{\xi}\Theta(\psi,\delta\psi)\right)$ (8)

where $\partial C$ is the boundary of $C$.

One can integrate this equation to obtain $H_{\xi}$ iff the right hand side is
a total variation, requiring

$\int_{\partial C}i_{\xi}\Theta(\psi,\delta\psi)=\delta\int_{\partial
C}i_{\xi}{\bf B}(\psi)$ (9)

Note that one can also express the condition for existence of $H_{\xi}$ in
terms of $[\delta_{1},\delta_{2}]H_{\xi}=0$:

$\int_{\partial C}i_{\xi}\omega(\psi,\delta_{1}\psi,\delta_{2}\psi)=0.$ (10)

The difference between Hamiltonians at two different $C$s is given by

$\left.\delta H_{\xi}\right|_{\partial C_{2}}-\left.\delta
H_{\xi}\right|_{\partial
C_{1}}=-\int_{B_{12}}{\bf\omega}(\psi,\delta\psi,{\cal L}_{\xi}\psi)$ (11)

where $B_{12}$ is a hypersurface with boundary $\partial C_{1}\sqcup\partial
C_{2}$. If (10) is satisfied by virtue of $\omega|_{B_{12}}=0$, then equation
(11) tells us that $H_{\xi}$ is independent of the slice $C$. We now review
the application of this formalism to AlAdS spacetimes, before discussing AldS
spacetimes.

## Asymptotically locally anti-de Sitter:

This case was fully analysed in [9]. The slice $C$ in (7) is a bulk spacelike
surface that ends on the boundary of AlAdS. Considering Dirichlet
conditions222Other boundary conditions may be obtained by adding finite
boundary terms that implement this change of boundary condition and tracking
their contributions, see also [45, 46]. , where the conformal class
$[g_{(0)}]$ is kept fixed, and a $[g_{(0)}]$ that admits conformal Killing
vectors, the integrability criterion (10) is automatically satisfied by virtue
of $\left.\omega(g_{\mu\nu},\delta
g_{\mu\nu},\mathcal{L}_{\xi}g_{\mu\nu})\right|_{B_{12}}=0$, where here $\xi$
is an asymptotic conformal Killing vector (ACKV), i.e. it approaches the
conformal Killing vectors $\zeta$ at the boundary, see appendix B of [9] for
the specific fall-off conditions) Then the Wald Hamiltonian integrates to (4).

Figure 2: Illustrating flux in an AlAdS spacetime. If flux arrives in
$B_{12}$, the gravitational charge at $C_{2}$ will differ from that in
$C_{1}$. The conformal boundary $\mathscr{I}$ is a timelike hypersurface and
the $C_{1},C_{2}$ are spacelike.

When there is gravitational radiation from the interior, it will reach the
conformal boundary at finite proper time. As a result, radiative AdS
spacetimes have a time-dependent boundary conformal structure, as was
confirmed recently in [56]. In such cases there are no conserved charges
because the boundary conformal structure does not admit conformal Killing
vectors. However, if the gravitational flux arrives in finite time intervals,
so that the boundary geometry outside these intervals admits conformal Killing
vectors, there will be piece-wise constant gravitational charges, and the
difference in their values between two instances of time will account for the
gravitational flux arriving at the conformal boundary, see Fig. 2. More
generally, if the spacetime admits a limit where conserved quantities exist,
then one can discuss the flux of such quantities away from that limit. An
example is the Robinson-Trautmann solution which we will discuss below in the
context of $\Lambda>0$.

## Asymptotically locally de Sitter:

We now consider AldS spacetimes with Dirichlet boundary conditions, i.e. we
keep fixed a conformal class at each end. Different boundary conditions may be
implemented as discussed in footnote 2. One may adapt straightforwardly all
steps of $\Lambda<0$ case to $\Lambda>0$; in most formulae this amounts to
differences in signs. However, there are important conceptual differences. The
analogue of the surface $C$ in (7) we used in the AlAdS case is now timelike,
and because the conformal boundary has two components, one at future infinity
and another at past infinity, such a $C$ will have two ends. Let us consider
the case where both past and future infinity admit conformal Killing vectors
and a hypersurface $C$ that extends from future infinity to past infinity. Let
$\xi$ be a bulk vector that is an ACKV near both past and future conformal
infinity, approaching a boundary conformal Killing vector $\zeta_{\pm}^{b}$ at
$\mathscr{I}^{\pm}$.Then

$H_{\xi}[C]=Q_{\xi}^{+}-Q^{-}_{\xi}$ (12)

where $Q^{\pm}_{\xi}[C]=\int_{\partial
C^{(\pm)}}ds_{a}T_{(\pm)b}^{a}\zeta_{\pm}^{b}$; $T_{(\pm)b}^{a}$ is the
holographic energy momentum tensor, and $\partial C^{\pm}$ are the two ends of
$C$. Now consider two such surfaces $C_{1}$ and $C_{2}$, see Fig. 3. Then (11)
implies

$\Delta Q_{\xi}^{+}(C_{1},C_{2})=\Delta Q_{\xi}^{-}(C_{1},C_{2})=0$ (13)

where $\Delta
Q_{\xi}^{\pm}(C_{1},C_{2})=Q^{\pm}_{\xi}[C_{1}]-Q^{\pm}_{\xi}[C_{2}]$. The
first equality in (13) follows from $\left.\omega(g_{\mu\nu},\delta
g_{\mu\nu},\mathcal{L}_{\xi}g_{\mu\nu})\right|_{B^{\pm}_{12}}=0$ and the
second from applying Stokes’ theorem to $\Delta Q_{\xi}^{\pm}$ independently
at $B_{12}^{\pm}$, using the explicit formulae for $Q^{\pm}_{\xi}$. It follows
that while the values of the charges may change from $\mathscr{I}^{-}$ to
$\mathscr{I}^{+}$, their difference is zero. Recall that $\mathscr{I}^{\pm}$
are Cauchy surfaces and consider any other Cauchy surface $I_{t}$. Then as we
now argue, $\Delta Q_{\xi}^{t}=\Delta Q_{\xi}^{-}$, where $\Delta
Q_{\xi}^{t}(C_{1},C_{2})=Q^{t}_{\xi}[C_{1}]-Q^{t}_{\xi}[C_{2}]$, and
$Q^{t}_{\xi}[C]=\int_{C\cap I_{t}}ds_{a}2\pi_{b}^{a}\xi^{b}$, with $\pi_{ab}$
the conjugate momentum of the induced metric at $I_{t}$ (here, for simplicity,
we assume that we deal with pure gravity). In other words, $\Delta
Q_{\xi}^{t}$ is conserved under time evolution, i.e. independent of the Cauchy
surface $I_{t}$. To see this, note that since $\omega$ is closed, its integral
over the boundary of the region enclosed by
$C_{1},C_{2},I_{t},\mathscr{I}^{-}$ is zero, so $\Delta Q_{\xi}^{-}$ must be
equal to $\Delta Q^{t}$ plus any flux passing through $B_{12}^{t}$. However,
there cannot be such flux, since any flux would eventually reach future
infinity and as a result the conformal class at $\mathscr{I}^{+}$ would not
admit conformal Killing vectors. Since we assume that future infinity admits
conformal Killing vectors, there cannot be gravitational flux in the interior,
and we find $\Delta Q_{\xi}^{-}=\Delta Q_{\xi}^{t}$. So while $Q_{\xi}^{t}$
may depend in $t$, $\Delta Q_{\xi}^{t}=0$ for all $t$. One may also check that
known solutions such as Kerr-de Sitter have $\Delta Q^{+}_{\xi}=0$.

In our discussion we consider timelike slices $C$ that extend from the future
infinity to past infinity. One may also consider hypersurfaces that start and
end at future infinity. Such $C$ may be obtained by using the portion of the
hypersurface $C_{1}$ from future infinity till $I_{t}$, then join $B_{12}^{t}$
and return to future infinity using (the time-reverse of) $C_{2}$.

Let us now consider the effects of radiation, i.e. we consider the case when
$\mathscr{I}^{+}$ admits no conformal Killing vectors. In this case the same
argument implies that $\Delta Q_{\xi}^{+}$ will differ from $\Delta
Q_{\xi}^{t}$ by the amount of net radiation in the region bounded by
$\mathscr{I}^{+},C_{1},C_{2}$ and $I_{t}$. In many previous discussions the
contribution from $I_{t}$ is either ignored or argued to be zero by
postulating suitable decay rates in the deep interior. Assuming $\Delta
Q_{\xi}^{t}=0$, any non-zero $\Delta Q_{\xi}^{+}$ will be due to gravitational
radiation at $\mathscr{I}^{+}$, captured explicitly via the future flux
formula [39, 45, 43]

$\Delta Q_{\xi}^{+}(C_{1},C_{2})=-\int_{B_{12}^{+}}\bm{F}_{\xi_{(0)}}$ (14)

where

$\bm{F}_{\xi_{(0)}}=\left(-\frac{1}{2}\sqrt{g_{(0)}}T^{ab}\mathcal{L}_{\xi_{(0)}}g^{(0)}_{ab}\right)\bm{\epsilon}_{3}.$
(15)

Figure 3: Timelike $C_{1},C_{2}$ intersecting spacelike conformal boundaries
$\mathscr{I}^{\pm}$ in AldS spacetime.

Using our formalism, we can also consider the case of $\Delta Q_{\xi}^{t}\neq
0$, i.e. account for radiation passing through the interior hypersurface
$I_{t}$. The past flux formula is

$\Delta Q_{\xi}^{t}(C_{1},C_{2})=-\int_{B_{12}^{t}}\bm{G}_{\xi}$ (16)

where

$\bm{G}_{\xi}=\left(-\sqrt{\gamma}\pi^{ab}L_{\xi}\gamma_{ab}\right)\bm{\epsilon}_{3}.$
(17)

In summary, the effect of gravitational radiation is to spoil the conservation
of spacelike separated charges. Combining equations (14) and (16), we see that
the explicit difference is given by

$\Delta Q^{+}-\Delta
Q^{t}=-\int_{B_{12}^{+}}\bm{F}_{\xi_{(0)}}+\int_{B_{12}^{t}}\bm{G}_{\xi}.$
(18)

## Robinson-Trautman

To conclude we discuss an example of a class of radiative dS solutions: the
Robinson-Trautman (RT) family. RT [57] describes an isolated system which
relaxes to equilibrium by radiating excess energy via gravitational waves,
becoming Schwarzschild dS. The solution exists for any value of the
cosmological constant, and here we discuss the $\Lambda>0$ case. The metric is

$ds^{2}=-\Phi_{\Lambda}du^{2}-2dudr+2r^{2}P^{-2}d\zeta d\bar{\zeta}\,,$ (19)

where $P=P(u,\zeta,\bar{\zeta})$ and

$\Phi_{\Lambda}=\Delta\ln P-2r(\ln
P)_{,u}-\frac{2m}{r}-\frac{\Lambda}{3}r^{2}\,.$ (20)

$\Delta=2P^{2}\partial^{2}/\partial\zeta\partial\bar{\zeta}$ and $P$ satisfies
the Robinson-Trautman equation:

$(\ln P)_{,u}+\frac{1}{12M}\Delta\Delta(\ln P)=0.$ (21)

Using results from [58], a representative of the conformal class at
$\mathscr{I}^{+}$ is

$ds_{(0)}^{2}=g_{(0)ab}dx^{a}dx^{b}=dy^{2}+\frac{6}{\Lambda}\hat{P}^{-2}d\zeta
d\bar{\zeta}$ (22)

where $\hat{P}$ denotes the boundary value of $P$. This metric generically
possesses no conformal Killing vectors and thus we cannot define charges.
However, as $y\to\infty$ the solution approaches Schwarzschild dS which has an
isometry related to mass, and therefore we may discuss its flux. Let us
consider a vector field which in this limit is associated with Bondi “time”
translation along the boundary (note that it is spacelike). The vector
generating these translations is

$\xi_{(0)}^{a}\partial_{a}=\frac{\hat{P}_{0}}{\hat{P}}\partial_{y}$ (23)

where $\hat{P}_{0}=1+\zeta\bar{\zeta}/2$ is the limit of $\hat{P}$ as
$y\to\infty$. The normalisation of this vector relates to the RTdS metric (19)
needing to undergo a coordinate transformation to be expressible in Bondi
gauge [59]. Exploiting results from [58], one can show that

$Q^{+}_{\xi}=\frac{2m}{\kappa^{2}}\int_{\partial
C^{+}}\left(\frac{P_{0}}{P}\right)^{3}\,d\mu_{0}$ (24)

where $d\mu_{0}$ is the area element on the unit $S^{2}$. This quantity is
analogous to the Bondi mass, $\mathcal{M}_{B}$, of RT in the asymptotically
flat setting [4]. It has been previously observed [60, 61, 58] that the
quantity defined in equation (24) is monotonically decreasing regardless of
the sign of $\Lambda$. Our construction thus illustrates explicitly how the
Bondi mass of the asymptotically flat RT solution arises in the current
context.

Since we have not used an asymptotic conformal Killing vector to construct
$\mathcal{M}_{B}$, we should expect to discover additional flux through
$B_{12}^{+}\subset\mathscr{I}^{+}$ when comparing the difference in Bondi mass
between the hypersurfaces $C_{1}$ and $C_{2}$. Applying equations (14) and
(15) to the RT solution, we find the following equation for the flux through
$B_{12}^{+}$:

$\Delta Q_{\xi}^{+}=\left.\mathcal{M}_{B}\right|_{\partial
C^{+}_{1}}-\left.\mathcal{M}_{B}\right|_{\partial
C^{+}_{2}}=-\int_{B_{12}^{+}}\bm{F}_{\xi_{(0)}}$ (25)

where

$\bm{F}_{\xi_{(0)}}=-\frac{2m}{\kappa^{2}}\partial_{y}\left(\frac{P_{0}}{P}\right)^{3}\sqrt{\mathring{\sigma}}\bm{\epsilon}_{3}$
(26)

and $\mathring{\sigma}_{AB}dx^{A}dx^{B}=2P_{0}^{-2}d\zeta d\bar{\zeta}$ is the
metric on the unit round $S^{2}$. This flux formula gives

$\left.\mathcal{M}_{B}\right|_{\partial
C^{+}_{1}}-\left.\mathcal{M}_{B}\right|_{\partial C^{+}_{2}}\leq 0\,.$ (27)

by monotonicity of the expression defined in equation (24) [60, 61]. We note
that the existence of this monotonically decreasing charge is unlikely to be a
feature of all AldS spacetimes, where charges may obey flux-balance laws
similar to those proposed in [44]. However, this analysis proves that all
metrics in the RT(A)dS family possess such a charge.

It would be interesting to compute $\Delta Q_{\xi}^{t}$ and confirm
monotonicity in $u$. For this we would need to know the form of Bondi time
translation vector field in the deep interior of the RT spacetime. We leave
this computation to future work.

## Conclusions

We have discussed the definition of charges in asymptotically locally de
Sitter spacetimes. We show that the difference of charges $\Delta
Q^{t}_{\xi}(C_{1},C_{2})$ defined using timelike surfaces $C_{1}$ and $C_{2}$
at the Cauchy surface $I_{t}$ is zero if gravitational flux is absent. If
there is gravitational flux the corresponding quantities differ by the net
amount of flux. We illustrated the latter with the example of Robinson-
Trautmann dS and derived a bound on the flux (27). It would be interesting to
exemplify our discussion with further explicit examples, investigate possible
connections with work on gravitational wave memory [62, 63, 64, 65, 66, 67,
68, 69], and analyse possible relevance to present and future gravitational
wave observations. Covariant phase space has been instrumental in formulating
in generality and obtaining a deep understanding of the first law of black
hole thermodynamics [49, 50]. Thermodynamics of black holes with de Sitter
asymptotics is still poorly understood and we believe the framework we develop
here and the issues we uncover are important in this context as well.

###### Acknowledgements.

Acknowledgments. KS and MT acknowledge support from the Science and Technology
Facilities Council (Consolidated Grant “Exploring the Limits of the Standard
Model and Beyond”). AP is supported by an EPSRC fellowship.

## References

  * Pirani [1957] F. A. E. Pirani, Invariant formulation of gravitational radiation theory, Phys. Rev. 105, 1089 (1957).
  * Trautman [1958] A. Trautman, Radiation and Boundary Conditions in the Theory of Gravitation, Bull. Acad. Pol. Sci. Ser. Sci. Math. Astron. Phys. 6, 407 (1958), arXiv:1604.03145 [gr-qc] .
  * Arnowitt  _et al._ [1959] R. L. Arnowitt, S. Deser, and C. W. Misner, Dynamical Structure and Definition of Energy in General Relativity, Phys. Rev. 116, 1322 (1959).
  * Bondi  _et al._ [1962] H. Bondi, M. G. J. van der Burg, and A. W. K. Metzner, Gravitational waves in general relativity. 7. Waves from axisymmetric isolated systems, Proc. Roy. Soc. Lond. A 269, 21 (1962).
  * Sachs [1962] R. Sachs, Asymptotic symmetries in gravitational theory, Phys. Rev. 128, 2851 (1962).
  * de Haro  _et al._ [2001] S. de Haro, S. N. Solodukhin, and K. Skenderis, Holographic reconstruction of space-time and renormalization in the AdS / CFT correspondence, Commun. Math. Phys. 217, 595 (2001), arXiv:hep-th/0002230 .
  * Fefferman and Graham [1985] C. Fefferman and C. Graham, Conformal Invariants, Elie Cartan et les Math ematiques d’aujourd’hui, Asterisque , 95 (1985).
  * Henningson and Skenderis [1998] M. Henningson and K. Skenderis, The Holographic Weyl anomaly, JHEP 07, 023, arXiv:hep-th/9806087 .
  * Papadimitriou and Skenderis [2005] I. Papadimitriou and K. Skenderis, Thermodynamics of asymptotically locally AdS spacetimes, JHEP 08, 004, arXiv:hep-th/0505190 .
  * Balasubramanian and Kraus [1999] V. Balasubramanian and P. Kraus, A Stress tensor for Anti-de Sitter gravity, Commun. Math. Phys. 208, 413 (1999), arXiv:hep-th/9902121 .
  * Skenderis [2001] K. Skenderis, Asymptotically Anti-de Sitter space-times and their stress energy tensor, Int. J. Mod. Phys. A 16, 740 (2001), arXiv:hep-th/0010138 .
  * Witten and Yau [1999] E. Witten and S.-T. Yau, Connectedness of the boundary in the AdS / CFT correspondence, Adv. Theor. Math. Phys. 3, 1635 (1999), arXiv:hep-th/9910245 .
  * Skenderis [2002] K. Skenderis, Lecture notes on holographic renormalization,  _The quantum structure of space-time and the geometric nature of fundamental interactions. Proceedings, RTN European Winter School, RTN 2002, Utrecht, Netherlands, January 17-22, 2002_ , Class. Quant. Grav. 19, 5849 (2002), arXiv:hep-th/0209067 [hep-th] .
  * Starobinsky [1983] A. A. Starobinsky, Isotropization of arbitrary cosmological expansion given an effective cosmological constant, JETP Lett. 37, 66 (1983).
  * Abbott and Deser [1982] L. F. Abbott and S. Deser, Stability of Gravity with a Cosmological Constant, Nucl. Phys. B 195, 76 (1982).
  * Ashtekar  _et al._ [2015a] A. Ashtekar, B. Bonga, and A. Kesavan, Asymptotics with a positive cosmological constant: I. Basic framework, Class. Quant. Grav. 32, 025004 (2015a), arXiv:1409.3816 [gr-qc] .
  * Ashtekar  _et al._ [2015b] A. Ashtekar, B. Bonga, and A. Kesavan, Asymptotics with a positive cosmological constant. II. Linear fields on de Sitter spacetime, Phys. Rev. D 92, 044011 (2015b), arXiv:1506.06152 [gr-qc] .
  * Ashtekar  _et al._ [2015c] A. Ashtekar, B. Bonga, and A. Kesavan, Asymptotics with a positive cosmological constant: III. The quadrupole formula, Phys. Rev. D 92, 104032 (2015c), arXiv:1510.05593 [gr-qc] .
  * Ashtekar  _et al._ [2016] A. Ashtekar, B. Bonga, and A. Kesavan, Gravitational waves from isolated systems: Surprising consequences of a positive cosmological constant, Phys. Rev. Lett. 116, 051101 (2016), arXiv:1510.04990 [gr-qc] .
  * Ashtekar [2017] A. Ashtekar, Implications of a positive cosmological constant for general relativity, Rept. Prog. Phys. 80, 102901 (2017), arXiv:1706.07482 [gr-qc] .
  * Ashtekar and Bahrami [2019] A. Ashtekar and S. Bahrami, Asymptotics with a positive cosmological constant. IV. The no-incoming radiation condition, Phys. Rev. D 100, 024042 (2019), arXiv:1904.02822 [gr-qc] .
  * Krtous  _et al._ [2003] P. Krtous, J. Podolsky, and J. Bicak, Gravitational and electromagnetic fields near a de Sitter - like infinity, Phys. Rev. Lett. 91, 061101 (2003), arXiv:gr-qc/0308004 .
  * Penrose [2011] R. Penrose, On cosmological mass with positive Lambda, Gen. Rel. Grav. 43, 3355 (2011).
  * Chruściel and Ifsits [2016] P. T. Chruściel and L. Ifsits, The cosmological constant and the energy of gravitational radiation, Phys. Rev. D 93, 124075 (2016), arXiv:1603.07018 [gr-qc] .
  * Chruściel  _et al._ [2021a] P. T. Chruściel, S. J. Hoque, and T. Smołka, Energy of weak gravitational waves in spacetimes with a positive cosmological constant, Phys. Rev. D 103, 064008 (2021a), arXiv:2003.09548 [gr-qc] .
  * Chruściel  _et al._ [2021b] P. T. Chruściel, S. J. Hoque, M. Maliborski, and T. Smołka, On the canonical energy of weak gravitational fields with a cosmological constant $\varLambda\in\mathbb{R}$, Eur. Phys. J. C 81, 696 (2021b), arXiv:2103.05982 [gr-qc] .
  * Bishop [2016] N. T. Bishop, Gravitational waves in a de Sitter universe, Phys. Rev. D 93, 044025 (2016), arXiv:1512.05663 [gr-qc] .
  * Date and Hoque [2016] G. Date and S. J. Hoque, Gravitational waves from compact sources in a de Sitter background, Phys. Rev. D 94, 064039 (2016), arXiv:1510.07856 [gr-qc] .
  * Date and Hoque [2017] G. Date and S. J. Hoque, Cosmological Horizon and the Quadrupole Formula in de Sitter Background, Phys. Rev. D 96, 044026 (2017), arXiv:1612.09511 [gr-qc] .
  * Hoque and Virmani [2018] S. J. Hoque and A. Virmani, On Propagation of Energy Flux in de Sitter Spacetime, Gen. Rel. Grav. 50, 40 (2018), arXiv:1801.05640 [gr-qc] .
  * Kolanowski and Lewandowski [2020] M. Kolanowski and J. Lewandowski, Energy of gravitational radiation in the de Sitter universe at $\mathcal{I}^{+}$ and at a horizon, Phys. Rev. D 102, 124052 (2020), arXiv:2008.13753 [gr-qc] .
  * Szabados and Tod [2015] L. B. Szabados and P. Tod, A positive Bondi–type mass in asymptotically de Sitter spacetimes, Class. Quant. Grav. 32, 205011 (2015), arXiv:1505.06637 [gr-qc] .
  * Saw [2017] V.-L. Saw, Mass loss due to gravitational waves with $\Lambda>0$, Mod. Phys. Lett. A 32, 1730020 (2017), arXiv:1704.07514 [gr-qc] .
  * Saw [2018] V.-L. Saw, Bondi mass with a cosmological constant, Phys. Rev. D 97, 084017 (2018), arXiv:1711.01808 [gr-qc] .
  * Szabados and Tod [2018] L. B. Szabados and P. Tod, A review of total energy–momenta in GR with a positive cosmological constant, Int. J. Mod. Phys. D 28, 1930003 (2018), arXiv:1808.09265 [gr-qc] .
  * Fernández-Álvarez and Senovilla [2020] F. Fernández-Álvarez and J. M. M. Senovilla, Gravitational radiation condition at infinity with a positive cosmological constant, Phys. Rev. D 102, 101502(R) (2020), arXiv:2007.11677 [gr-qc] .
  * Fernández-Álvarez and Senovilla [2021] F. Fernández-Álvarez and J. M. M. Senovilla, Asymptotic Structure with a positive cosmological constant, (2021), arXiv:2105.09167 [gr-qc] .
  * Balasubramanian  _et al._ [2002] V. Balasubramanian, J. de Boer, and D. Minic, Mass, entropy and holography in asymptotically de Sitter spaces, Phys. Rev. D 65, 123508 (2002), arXiv:hep-th/0110108 .
  * Anninos  _et al._ [2011] D. Anninos, G. S. Ng, and A. Strominger, Asymptotic Symmetries and Charges in De Sitter Space, Class. Quant. Grav. 28, 175019 (2011), arXiv:1009.4730 [gr-qc] .
  * Anninos  _et al._ [2012] D. Anninos, G. S. Ng, and A. Strominger, Future Boundary Conditions in De Sitter Space, JHEP 02, 032, arXiv:1106.1175 [hep-th] .
  * Kelly and Marolf [2012] W. R. Kelly and D. Marolf, Phase Spaces for asymptotically de Sitter Cosmologies, Class. Quant. Grav. 29, 205013 (2012), arXiv:1202.5347 [gr-qc] .
  * Prema Balakrishnan  _et al._ [2019] A. Prema Balakrishnan, S. J. Hoque, and A. Virmani, Conserved charges in asymptotically de Sitter spacetimes, Class. Quant. Grav. 36, 205008 (2019), arXiv:1902.07415 [hep-th] .
  * Kolanowski and Lewandowski [2021] M. Kolanowski and J. Lewandowski, Hamiltonian charges in the asymptotically de Sitter spacetimes, JHEP 05, 063, arXiv:2103.14674 [gr-qc] .
  * Compère  _et al._ [2019] G. Compère, A. Fiorucci, and R. Ruzziconi, The $\Lambda$-BMS4 group of dS4 and new boundary conditions for AdS4, Class. Quant. Grav. 36, 195017 (2019), arXiv:1905.00971 [gr-qc] .
  * Compère  _et al._ [2020] G. Compère, A. Fiorucci, and R. Ruzziconi, The $\Lambda$-BMS4 charge algebra, JHEP 10, 205, arXiv:2004.10769 [hep-th] .
  * Fiorucci and Ruzziconi [2021] A. Fiorucci and R. Ruzziconi, Charge algebra in Al(A)dSn spacetimes, JHEP 05, 210, arXiv:2011.02002 [hep-th] .
  * Crnković and Witten [1987] C. Crnković and E. Witten, Covariant description of canonical formalism in geometrical theories, in Three Hundred Years of Gravitation, edited by S. W. Hawking and W Israel (Cambridge U.P., Cambridge, 1987).
  * Lee and Wald [1990] J. Lee and R. M. Wald, Local symmetries and constraints, J. Math. Phys. 31, 725 (1990).
  * Wald [1993] R. M. Wald, Black hole entropy is the Noether charge, Phys. Rev. D 48, R3427 (1993), arXiv:gr-qc/9307038 .
  * Iyer and Wald [1994] V. Iyer and R. M. Wald, Some properties of Noether charge and a proposal for dynamical black hole entropy, Phys. Rev. D 50, 846 (1994), arXiv:gr-qc/9403028 .
  * Iyer and Wald [1995] V. Iyer and R. M. Wald, A Comparison of Noether charge and Euclidean methods for computing the entropy of stationary black holes, Phys. Rev. D 52, 4430 (1995), arXiv:gr-qc/9503052 .
  * Wald and Zoupas [2000] R. M. Wald and A. Zoupas, A General definition of ’conserved quantities’ in general relativity and other theories of gravity, Phys. Rev. D 61, 084027 (2000), arXiv:gr-qc/9911095 .
  * Harlow and Wu [2020] D. Harlow and J.-Q. Wu, Covariant phase space with boundaries, JHEP 10, 146, arXiv:1906.08616 [hep-th] .
  * Chandrasekaran  _et al._ [2021] V. Chandrasekaran, E. E. Flanagan, I. Shehzad, and A. J. Speranza, A general framework for gravitational charges and holographic renormalization, (2021), arXiv:2111.11974 [gr-qc] .
  * Barnich and Brandt [2002] G. Barnich and F. Brandt, Covariant theory of asymptotic symmetries, conservation laws and central charges, Nucl. Phys. B 633, 3 (2002), arXiv:hep-th/0111246 .
  * Poole  _et al._ [2019] A. Poole, K. Skenderis, and M. Taylor, (A)dS4 in Bondi gauge, Class. Quant. Grav. 36, 095005 (2019), arXiv:1812.05369 [hep-th] .
  * Robinson and Trautman [1960] I. Robinson and A. Trautman, Spherical Gravitational Waves, Phys. Rev. Lett. 4, 431 (1960).
  * Bakas and Skenderis [2014] I. Bakas and K. Skenderis, Non-equilibrium dynamics and $AdS_{4}$ Robinson-Trautman, JHEP 08, 056, arXiv:1404.4824 [hep-th] .
  * Aranha  _et al._ [2013] R. F. Aranha, I. Damiao Soares, and E. V. Tonini, The Bondi-Sachs 4-momentum in non-axisymmetric Robinson-Trautman spacetimes, Class. Quant. Grav. 30, 025014 (2013).
  * Chruściel [1991] P. Chruściel, Semiglobal existence and convergence of solutions of the Robinson-Trautman (two-dimensional Calabi) equation, Commun. Math. Phys. 137, 289 (1991).
  * Chrusciel [1992] P. T. Chrusciel, On the global structure of Robinson-Trautman space-times, Proc. Roy. Soc. Lond. A 436, 299 (1992).
  * Chu [2015] Y.-Z. Chu, Transverse traceless gravitational waves in a spatially flat FLRW universe: Causal structure from dimensional reduction, Phys. Rev. D 92, 124038 (2015), arXiv:1504.06337 [gr-qc] .
  * Bieri  _et al._ [2016] L. Bieri, D. Garfinkle, and S.-T. Yau, Gravitational wave memory in de Sitter spacetime, Phys. Rev. D 94, 064040 (2016), arXiv:1509.01296 [gr-qc] .
  * Kehagias and Riotto [2016] A. Kehagias and A. Riotto, BMS in Cosmology, JCAP 05, 059, arXiv:1602.02653 [hep-th] .
  * Chu [2017a] Y.-Z. Chu, Gravitational Wave Memory In dS4+2n and 4D Cosmology, Class. Quant. Grav. 34, 035009 (2017a), arXiv:1603.00151 [gr-qc] .
  * Tolish and Wald [2016] A. Tolish and R. M. Wald, Cosmological memory effect, Phys. Rev. D 94, 044009 (2016), arXiv:1606.04894 [gr-qc] .
  * Chu [2017b] Y.-Z. Chu, More On Cosmological Gravitational Waves And Their Memories, Class. Quant. Grav. 34, 194001 (2017b), arXiv:1611.00018 [gr-qc] .
  * Hamada  _et al._ [2017] Y. Hamada, M.-S. Seo, and G. Shiu, Memory in de Sitter space and Bondi-Metzner-Sachs-like supertranslations, Phys. Rev. D 96, 023509 (2017), arXiv:1702.06928 [hep-th] .
  * Bieri  _et al._ [2017] L. Bieri, D. Garfinkle, and N. Yunes, Gravitational wave memory in $\Lambda$CDM cosmology, Class. Quant. Grav. 34, 215002 (2017), arXiv:1706.02009 [gr-qc] .