## 1. Introduction and Background

Optimising the location of

opto-electro-optical (

OEO)

regenerators (hereafter referred to as

relays) in

optical networks (ONs) has, for much of the history of ONs, been considered a

static problem [

1]. Such devices have, until recently, been expensive to both install and operate. In consequence, optimisation of relay placement has been performed offline, with complex algorithms, leading to solutions to be implemented as part of a fixed, long-term network structure [

2]. Recent years, however, have seen two significant developments in the field:

The introduction of

flexible optical network (

FON) technology has led to ONs having the ability to vary transmission parameters to support changing traffic requirements. By modulating across larger bandwidths, FONs can achieve higher bitrates at the expense of shorter transmission distances (whereas, conversely, greater transmission distances can be achieved for lower bitrates) [

3].

The production and installation of OEOs (relays) has fallen sharply due to both improved manufacturing processes and refinements to carrier/switching technologies, although running costs, in terms of power consumption, are still high [

4]. Consequently, installing relays in multiple locations but using (powering) them selectively (as, and when, required) may lead to greater efficiencies.

Describing the engineering principles behind these advances is beyond the scope of this work [

5]. However, in essence, the new technology (1) makes the optimisation of relay management a

dynamic problem [

6] whilst the emphasis on running costs (2) redefines its

objective [

7]. As a result, optimising ‘placement’ of relays becomes an optimisation of relay ‘use’. Higher traffic will mean larger bandwidths, shorter transmission limits and, thus, the need for more frequent regeneration and greater numbers of relays.

The next section considers comparable optimisation problems, which yield some insight into the task at hand.

Section 3 gives the initial formulation and complexity discussion. Useful related approaches are considered in

Section 4, and these lead to the proposed algorithm in

Section 5, which also provides the proof of NP-completeness.

Section 6 tests the algorithm with two known library networks. In

Section 7, the problem, and its solution, are generalised and the complexity considered once more.

Section 8 suggests future work for other researchers. The paper’s overall structure, switching as it does between definition and solution, may appear odd, but this approach is considerably shorter than dealing with each thread independently in turn. For the same reason, the notation is also slightly informal in places.

## 3. Formulation of the Problem

In this paper, we use a simple model of the problem, with possible extensions considered in

Section 7. Some of these extensions are, in fact, straightforward, but are omitted initially to minimise the requirements of the initial notation. Additionally, in what follows, we use a number of standard logical, set-theoretic, and optimisation-based concepts and abbreviations, namely: there are

n nodes in the ON/FON, numbered

1,

2,

…,

n −

1,

n; the logical operators ‘AND’ and ‘OR’ are represented by ‘∧’ and ‘∨’ respectively; ‘Such that’ is abbreviated to ‘

s.t.’ and ‘TRUE’ and ‘FALSE’ to ‘

T’ and ‘

F’; |

S| represents the size (‘cardinality’) of the set

S; and, finally, the universal and existential operators ‘

$\forall $’ and ‘

$\exists $’ (‘for all’ and ‘there exists’) refer explicitly to the set of nodes

1,

2,

…,

n −

1,

n (hereafter omitted).

For a given node set and link configuration (

Figure 1), define the

relay vector,

r, as:

r =

(r_{k}) where

$\forall $k,

r_{k} =

T if the relay at node

k is switched on (powered);

r_{k} =

F otherwise.

r defines relay use for a given configuration. Initially, we suppose that relays are placed at all nodes but are only activated when required (see

Ext1 in

Section 7). Let

m be the maximum number of hops for which an optical signal can be transmitted without the need for regeneration by an OEO (relay). A hop is a single link between adjacent nodes (see

Ext2 in

Section 7). The critical feature of a FON is that changing transmission parameters, to dynamically increase or decrease bandwidth, will cause

m to vary (

m will decrease with higher bitrates and increase with lower bitrates). Initially, we take

m to be a single (but not static) parameter across the FON (see

Ext3 in

Section 7). As

m varies, different requirements will be placed (dynamically) on relay placement,

r. In the FON fragment in

Figure 2a, for example, values for

m of

1,

2, and

3 cannot be sustained, whereas an

m value of

4 can. In

Figure 2b, now with

r_{k} =

T, values of

m =

4,

m =

3, and

m =

2 can all be sustained, and only

m =

1 cannot.

The cost of a solution, r, is then the number of relays switched on in any given configuration. C(r) = |{k: r_{k} = T}| (the cardinality of the set of powered relays).

The optimisation problem ‘Dynamically Powered Relays for a Flexible Optical Network’ (DRP-FON) is, thus, defined as:

DRP-FON: Minimise C(r) [objective function]
s.t. m [constraint]

**Theorem.** DRP-FON is NP-Complete.

**Proof.** (informal) Intuitively, by direct reduction to the ‘Minimum Dominating Set’ (MDS) [

19] (note, not MCDS [

20], since the relays do not, themselves, have to form a connected core) and demonstration of polynomial certification (the full version follows). ☐

## 5. A Fast Heuristic Solution

Assuming the need for a FON configuration supporting a given value of m, a fast heuristic for DRP-FON is constructed as follows:

Define the

hop matrix,

H, as

H =

(h_{ij}) where

$\forall $ij,

h_{ij} = |

{a: link a is in the shortest path between i and j}| (the length of the shortest path, in hops, between nodes

i and

j) (

h_{16} =

4 in

Figure 1, for example). The first subroutine, using Dijkstra’s Shortest Path Algorithm [

18] (or similar) [

24], is then:

AlgH (Calculate the hop matrix):
∀ ij, run DSPA to calculate H = (h_{ij})

(Note that DSPA only runs once to calculate each row of the matrix, H, not individually for each element, h_{ij}.)

The second subroutine calculates the

viability matrix,

V =

(v_{ij}), defined by the existence of a path between each node pair satisfying

m. For each

ij pair,

v_{ij} =

T if the hop count between

i and

j is, at most,

m, or a sequence of relays can be found between

i and

j with the hop count of each step between, at most,

m relays.

AlgV (Calculate the viability matrix):
∀ ij, set v_{ij} = T if (h_{ij} ≤ m) ∨ (∃ k … l, … s.t. (r_{k} ∧ … ∧ r_{l} = T)
∧ (h_{ik} ≤ m ∧ … ∧ h_{lj} ≤ m));
v_{ij} = F otherwise

With this definition, we may now revisit the NP-completeness theorem:

**Theorem.** DRP-FON is NP-Complete.

**Proof.** DRP-FON is NP-hard since, for

m =

1, it reduces to the ‘Minimum Dominating Set’ (MDS) [

15].

A certificate for DRP-FON can be verified in polynomial time by the following algorithm:
run AlgH
run AlgV
if v_{ij} = T ∀ ij then
certificate valid
else
certificate invalid

Since DRP-FON is NP-hard and has polynomial time certificate verifiability, it is NP-complete. ☐

Returning to the solution, the complete algorithm starts by initialising all relays to be switched off (unpowered), then uses a greedy (limited local search) heuristic to switch relays on (power), one at a time. The relay to be newly powered is that which has a viable path (i.e., with or without intermediate relays), of a length no greater than

m, to the largest number of other nodes,

not currently acting as relays—thus, maximising the number of

new nodes that are ‘reached/spanned’ by the extra relay. The algorithm terminates when the overall solution becomes viable, i.e., when paths between all node pairs (with or without intermediate relays) are viable. This includes the special case that the initial solution is viable without any relays.

AlgR (Optimise the relay array): // DRP-FON-heuristic
setr_{k} = F ∀ k // All relays switched off
run AlgH // Calculate hop lengths
run AlgV // Calculate viable paths
while ∃ ij s.t. v_{ij} = F do // if more relays needed
{ find k s.t. |{i: (v_{ik} = T) ∧ (r_{i} = F)}| // Find relay that
≥ |{ i: (v_{ij} = T) ∧ (r_{i} = F)}| ∀ j // … reaches most nodes
setr_{k} = T // Power this new relay
run AlgV } // Recalculate viable paths

Note, once more, that the relays need not form a connected network. The DRP-FON heuristic, AlgR, can be considered an extension of the greedy ‘ADD’ algorithm in [

16] with the maximal metric for relay selection extended to include those nodes within a ‘radius’ of

m from each candidate location.

## 6. Testing and Evaluation

AlgR has polynomial complexity. In the initialisation part, switching off all relays has complexity

O(n). DSPA (AlgH) is bounded by

O(

n^{3}) [

18] and can generally be implemented as

O(

n^{2}) [

24]. Similarly, AlgV is

O(

n^{3}), at worst, but

O(

n^{2}) in practice. Anyway, this part is only executed once. The more significant non-deterministic

while loop, in fact, iterates at most

n times (a maximum of

n nodes/relays to potentially switch on). Within it is a maximisation search of

O(

n^{2}), giving an overall complexity of

O(

n^{3}).

To evaluate AlgR, we use two standard test examples [

25] and compare with a ‘brute force’ approach [

23].

Figure 3 and

Figure 4 shows the standard ‘US NSF’ and ‘COST-266 European’ optical networks with distances ignored (since we initially only consider node adjacency). For COST-266, there are

2^{28} possible relay ‘on/off’ combinations, which is manageable for a simple exhaustive search algorithm with some patience.

Table 1 compares AlgR with the known optimum generated by brute force. Each solution has been coded in C# running on a standard desktop PC. AlgR ran within a tenth of a second in each case; the exhaustive search, considerably longer.

Table 1 shows the amount (number of powered relays) by which AlgR performs

worse than the ‘perfect’ exhaustive search algorithm for different

m constraints (not all values of

m are meaningful: when

m reaches the length of the longest path between any nodes, for example,

no relays are needed) It might be reasonable to expect the performance of the AlgR heuristic to improve with larger values of

m as smaller numbers of relays suffice, but this pattern does not emerge clearly in these two test instances.

For these small examples, individual analysis may be specious; however,

Table 1 represents a mean increase of 14% in

C(r) above the known optima over all sensible values of

m in both cases. This is comparable with (in fact, somewhat better than) similar examples in which a crude/fast (polynomial) heuristic replaces a complex/slow metaheuristic [

26] or (exponential) exhaustive search [

13]. However, additional testing is still clearly needed.

## 7. Extensions and Generalisations

DRP-FON has been defined, in this paper, for simplicity of the initial analysis, solution, and testing. There are a number of respects in which it may be too simple for widespread application. In particular, the following real-world extensions may be considered:

Ext1: Relays are only permitted at certain nodes: This is a likely extension to the basic model, reflecting restrictions on equipment installation at some locations or resulting from network management strategies, such as only installing regenerators at some (half, say) of all locations. It is easily dealt with by a simple restriction on the r array or, if necessary, a separate p ‘permitted’ array. The adaptation of AlgV and AlgR is then trivial.

Ext2: Use physical distances instead of hop counts: If regeneration limits are to be measured by cumulative distance, rather than merely hop count, then reachability becomes an issue of both fixed physical edge weight, W = (w_{ij}) (the Euclidean distance between i and j, for example), and the dynamically-changing limit, m, as transmission parameters vary. As a result, the viability matrix, V, is calculated by natural extension to AlgH and AlgV, and AlgR remains essentially unaltered.

Ext3: Allow different transmission limits for each node pair: The basic model assumes the same changes in transmission parameters and, hence, m, across the FON. However, if transmission parameters are allowed to vary locally (independently) then the single value of m will need to extend to a matrix of limits, M. Nevertheless, individual values, v_{ij}, of the viability matrix, V, can be calculated, without difficulty, using the appropriate element, m_{ij}: AlgV and AlgR otherwise work as before.

Taking these three classes of extension together gives a new optimisation problem to be considered. Firstly, we define the permitted/present vector, p, as p = (p_{k}) where $\forall $k, p_{k} = T if a relay is allowed/installed at node k; p_{k} = F otherwise. p is a physical network constraint for any node set. Then, as before, for any given solution, the relay vector, r, is defined as: r = (r_{k}) where $\forall $k, r_{k} = T if the relay at node k is switched on (powered); r_{k} = F otherwise.

Next, we include the physical distance (or any appropriate metric) by introducing the weight matrix,

W =

(w_{ij}), where

w_{ij} represents the ‘weight’ of the link between

i and

j (if present). In the simplest case,

w_{ij} represents the Euclidean distance between the two nodes (

Figure 5). However, other uses are possible to discourage the use of inappropriate paths, etc. [

12].

Finally, we extend our transmission limit concept to allow local variation across the FON. On this basis, we define the maximum hop matrix, M = (m_{ij}), where m_{ij} is the maximum number of hops for which an optical signal can be transmitted, between nodes i and j, without the need for regeneration by a relay.

As before, the cost of a solution, r, is then the number of relays switched on (the cardinality of the set of powered relays) in any given configuration (now defined by both M and W). C(r) = |{k: r_{k} = T}|.

The new optimisation problem ‘Generalised Dynamically Powered Relays for a Flexible Optical Network’ (GDRP-FON) is, thus, defined as:

GDRP-FON: Minimise C(r)[objective function]
s.t. M, W [constraint]

**Theorem.** GDRP-FON is NP-complete.

**Proof.** (informal) Intuitively, by direct reduction to DPR-FON and the demonstration of polynomial certification (the full version follows). ☐

We now proceed to build a revised fast heuristic for GDRP-FON as follows:

Once again, define the hop matrix, H, as H = (h_{ij}) where $\forall $ij, h_{ij} = |{a: link a is in the shortest path between i and j}|. However, now for the extended GDRP-FON problem, these hop counts have to take into account link weights, W = (w_{ij}). Consequently, the first extended subroutine, AlgGH, again using Dijkstra’s Shortest Path Algorithm becomes:

AlgGH (Calculate hop matrix):

∀ij, run DSPA to calculate H = (h_{ij}) using the weightings, W = (w_{ij}) as SPA edge costs (W: input; H: output) (note that DSPA still only runs once to calculate each row of the matrix, H, not individually for each element, h_{ij}. Additionally, although the w_{ij} values define actual weightings, the shortest path (the result), in each case, need only be recorded in hops, h_{ij}).

The second subroutine, AlgGV, calculates the viability matrix, V = (v_{ij}), which now has to be extended in two respects. In defining the existence of a path between each node pair ij, satisfying m_{ij} (now a local value), it must also take into account whether a relay is present or permitted at each node k. For each ij node pair, then, v_{ij} = T if the hop count between i and j is at most m_{ij} or a sequence of permitted relays can be found between i and j with the hop count of each step between relays k and l at most m_{kl} (the limit is applied independently for each relay pair).

AlgGV (calculate the viability matrix):
∀ij, setv_{ij} = Tif(h_{ij} ≤ m_{ij})
∨ (∃k …l, … s.t. (p_{k} ∧ … ∧ p_{l}
∧ r_{k} ∧ … ∧ r_{l} = T)
∧ (h_{ik} ≤ m_{ik} ∧ … ∧ h_{lj} ≤ m_{lj}));
v_{ij} = Fotherwise

This now allows us to reconsider the NP-completeness proof:

**Theorem.** GDRP-FON is NP-complete.

**Proof.** GDRP-FON is NP-hard since, for p_{k} = T ∀k, d_{ij} = h_{ij} ∀ij and w_{ij} = m_{ij} = constant ∀ij,
DRP-FON reduces to it.
As before, a certificate for GDRP-FON can be verified in polynomial time by the
following algorithm:
run AlgGH
run AlgGV
if v_{ij} = T∀ij then
certificate valid
else
certificate invalid
Since GDRP-FON is NP-Hard and has polynomial time certificate verifiability, it is
NP-complete.

☐

Again we return to the development of an equivalent fast heuristic for GDRP-FON, combining the newly-extended AlgGH and AlgGV subroutines. Once again, the complete algorithm starts by initialising all relays to be switched off, then uses a greedy heuristic to switch on permitted relays, one at a time. The relay to be newly-powered is that which (is permitted and) has viable paths to the largest number of other nodes, not currently acting as relays—thus maximising the number of new nodes that are ‘reached/spanned’ by the extra relay. Again, the algorithm terminates when the overall solution becomes viable, i.e., when paths between all node pairs (with or without intermediate relays) are viable.

AlgR (Optimise relay array): // GDRP-FON-heuristic
setr_{k} = F ∀k // All relays switched off
run AlgGH // Calculate hop lengths
run AlgGV // Calculate viable paths
while ∃ij s.t. v_{ij} = F do // if more relays needed
{ find k s.t. |{i: (v_{ik} = T) ∧ (r_{i} = F)}| // Find relay that
≥ |{ i: (v_{ij} = T) ∧ (r_{i} = F)}| ∀j // … reaches the most nodes
setr_{k} = T // Power this new relay
run AlgGV } // Recalculate viable paths

As before, the GDRP-FON heuristic, AlgGR, can be considered an extension of the greedy ‘ADD’ algorithm in [

16]. Again, it deals with the special case of an initial configuration (and values of

M and

W) requiring

no relays. Additionally, as before, AlgGR is polynomial by a similar argument.

At this stage of the research, however, the AlgGR fast heuristic remains untested. Although AlgGR itself runs quickly, the brute force approach to finding the optimal comparison becomes intractable for GDRP-FON. A reliable branch-and-price-and-cut [

22] or metaheuristic [

21] will have to be developed.