GRAPH MUTATION,
           GRAPH DISTANCE,
                     AND
           GRAPH GRADIENT
                      By
       Mohammad Hosein Khalifeh
            A DISSERTATION
                 Submitted to
        Michigan State University
 in partial fulfillment of the requirements
              for the degree of
Computer Science – Doctor of Philosophy
                     2023


                                          ABSTRACT
     Most networks constantly change, and predicting links or recovering from link failures
is crucial for maintaining a network. Distance-based graph invariants are important
criteria for network maintenance. A graph mutation is a change in the edge set of a graph,
and a graph gradient is the change in a graph invariant after a mutation. We present the
general concepts of discrete integral and derivative for vertex and edge weighted graphs
as a tool. Using the concepts, some related problems are solved more efficiently, flexibly,
and simpler than the existing solutions.
     Let 𝐺 = (𝑉(𝐺), 𝐸(𝐺)) be a graph with vertex weight function 𝑓𝐺 and edge weight
function 𝑤𝐺 . And 𝑑𝐺 (𝑢, 𝑣) denotes the distance of 𝑢, 𝑣 ∈ 𝑉(𝐺), the minimum sum of edge
weights across all the paths connecting 𝑢 and 𝑣. Then assume.
           𝑊𝛼,𝛽 (𝐺) = ∑{𝑢,𝑣}⊆𝑉(𝐺)[𝛼𝑓𝐺 (𝑢) × 𝑓𝐺 (𝑣) + 𝛽(𝑓𝐺 (𝑢) +𝑓𝐺 (𝑣))]𝑑𝐺 (𝑢, 𝑣), 𝛼, 𝛽 ∈ ℝ,
     and 𝑇 is a spanning tree (ST) of 𝐺. If an edge 𝑒 ∈ 𝐸(𝑇) fails, it creates 𝑇 − 𝑒 with two
components. If 𝑇 − 𝑒 reconnected with 𝜖 ∈ 𝐸(𝐺)\𝐸(𝑇) and form 𝑇𝜖\𝑒 = 𝑇 + 𝜖 − e such
that 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ) is minimum, then 𝜖 is a best swap edge (BSE) of 𝑒 w.r.t 𝑊 𝛼,𝛽 . We devise
an algorithm that finds a BSE 𝜖 ∈ 𝐸(𝐺)\𝐸(𝑇) w.r.t 𝑊 𝛼,𝛽 for each 𝑒 ∈ 𝐸(𝑇) and computes
𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ). We call the algorithm “all best swap edges w.r.t. 𝑊 𝛼,𝛽 ”(ABSEW).
Preprocessing for ABSEW takes 𝑂(𝑛)-time, whereas solving ABSEW has an average time-
complexity of 𝑂((𝑚 − 𝑛)log 𝑛) and a best time-complexity of 𝑂(𝑚 − 𝑛), all in 𝑂(𝑚)-space,
where (𝑚, 𝑛) = (|𝐸(𝐺)|, |𝑉(𝐺)|). For dense graphs, however, the average time reaches
𝑂(𝑚 − 𝑛). 𝑇’s routing cost (RC) for a given set of sources 𝑆 ⊆ 𝑉(𝐺) equals
∑(𝑎,𝑏)∈𝑉(𝑇)×𝑆 𝑑𝑇 (𝑢, 𝑣). For 2-edge-connected positively edge-weighted graphs and some
specified |𝑆|, researchers have found a BSE for each edge of an ST w.r.t. RC. The solutions
have time complexities of 𝑂(𝑚2𝑂(𝛼(2𝑚,2𝑚)) . log 2 𝑛) (|𝑆| = 𝑂(1) or 𝑛), 𝑂(𝑚. log 𝑛 + 𝑛2 )
(|𝑆| = 2), and 𝑂(𝑚𝑛) (|𝑆| > 2) for the specified |𝑆|’s. Our algorithm outperforms existing
algorithms regarding RC with no limit on |𝑆|, edge and vertex weights, or graph type,
while also computing the RC for each BSE.


     Assume 𝑇 is a positively weighted 𝑛-vertex tree, and 𝑒 ∈ 𝐸(𝑇) fails. If we reconnect
the components of 𝑇 − 𝑒 with 𝜖 ∈ 𝐸(𝑇 𝑐 ) such that, 𝑊 𝛼,𝛽 (𝑇𝜖\𝑒 ) is minimum, then 𝜖 is
called a best switch (BS) of 𝑒 w.r.t. 𝑊𝛼,𝛽 . For the inputs 𝑒 ∈ 𝐸(𝑇) and 𝑤, 𝛼, 𝛽 ∈ ℝ+ , we
find 𝜖, 𝑇𝜖\𝑒 , and 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ) with the worst average time of 𝑂(log 𝑛) and the best average
time of 𝑂(1) where 𝜖 is a BS of 𝑒 w.r.t. 𝑊𝛼,𝛽 and the weight of 𝜖 is 𝑤. There are comparable
algorithms to ours only w.r.t 𝑊1,0 or 𝑊 0,1 which are relatively complicated and limited.
In our algorithm 𝛼, 𝛽 can be changed at any step without affecting complexities or
preprocessing.
     A subgraph 𝐻 of a simple graph 𝐺 is isomeric if 𝑑𝐺 (𝑢, 𝑣) = 𝑑𝐻 (𝑢, 𝑣), ∀𝑢, 𝑣 ∈ 𝑉(𝐻).
And 𝐺 is distance-preserving if it has at least a 𝑘-vertex isometric subgraph for each 𝑘,
1 ≤ 𝑘 ≤ |𝑉(𝐺)|. There is a relatively old conjecture by Nussbaum and Esfahanian that
                     𝑛
says: if deg 𝐺 (𝑣) > 2, ∀𝑣 ∈ 𝑉(𝐺), then G is distance-preserving. We will have a close
asymptotic approach to the conjecture.
     One added edge to a simple graph 𝐺 (𝑤𝐺 = 1) is called inset edge and mutates 𝐺.
Establishing some regular and extensive matrix tools, we devised an algorithm that
computes and sorts the gradient of the inset edges of a tree regarding the total distance,
𝐷(𝐺) = ∑{𝑢,𝑣}⊆𝑉(𝐺) 𝑑𝐺 (𝑢, 𝑣) for 𝐺. The algorithms’ average time complexity is minimal,
reducing the previous algorithm from 𝑂(𝑛5 ) to an average of 𝑛2 𝑂(log 𝑛), where 𝑛 = |𝑉(𝐺)|.
Indeed, we compute the total distance of 𝑂(𝑛2 ) unicyclic graphs each on average of
𝑂(log 𝑛)-time and the best time of 𝑂(1).


Copyright by
MOHAMMAD HOSEIN KHALIFEH
2023


Dedicated to Mom and Dad
            v


                                TABLE OF CONTENTS
LIST OF ABREVIATIONS ................................................................................... viii
LIST OF SYMBOLS.................................................................................................. ix
CHAPTER 1: DEFINITIONS AND NOTATIONS ............................................ 1
     1.1 Basic Definitions ............................................................................................. 1
     1.2 Problems Statement ....................................................................................... 7
         1.2.1 Best Swap Edge of Optimal Spanning Trees.......................................... 7
         1.2.2 Best Switch Edge of Trees ..................................................................... 9
         1.2.3 Distance Preserving Graphs and 𝛿 ........................................................ 10
         1.2.4 Inset Edge of Trees and Wiener Index .................................................. 11
     REFERENCES ................................................................................................... 12
CHAPTER 2: DISCRET CALCULUS .................................................................. 14
     2.1 Discrete Derivative ........................................................................................ 15
     2.2 Discrete Integral ............................................................................................ 20
     APPENDIX......................................................................................................... 22
CHAPTER 3: BEST SWAP EDGE OF OPTIMAL SPANNING TREES.... 25
     3.1 Introduction ................................................................................................... 25
     3.2 Gradient of Swap Edges ................................................................................ 28
     3.3 All BSE Algorithm ........................................................................................ 34
     3.4 Examples and ABSEW algorithm for ABSER............................................... 37
     REFERENCES ................................................................................................... 39
CHAPTER 4: BEST SWITCH EDGE OF TREES ............................................ 41
     4.1 Introduction ................................................................................................... 41
     4.2 Main Algorithm for Switch and 𝑊𝛼,𝛽 ............................................................. 44
     4.3 Some Comparisons and Discussion ................................................................ 58
     REFERENCES ................................................................................................... 60
     APPENDIX......................................................................................................... 63
CHAPTER 5: DISTANCE PRESERVING GRAPHS AND 𝜹 ........................ 64
     5.1 Introduction ................................................................................................... 64
     5.2 On Distance Preserving Conjecture ............................................................... 65
     REFERENCES ................................................................................................... 68
CHAPTER 6: INSET EDGE OF TREES AND WIENER INDEX ................ 69
     6.1 Introduction ................................................................................................... 69
     6.2 Main Tools and Preliminary Results ............................................................. 70
                                                        vi


6.3 Main Result: An algorithm For Inset Edge of Trees ...................................... 88
    6.3.1 Some Tools to Divide and Conquer ...................................................... 88
    6.3.2 A Matrix Norm Technique.................................................................... 91
    6.3.3 Main Algorithm for Inset Edge of Trees ............................................... 94
    6.3.4 Algorithm Complexity and Conclusion ................................................. 98
REFERENCES ................................................................................................. 101
APPENDIX A: EQUATIONS 6-10 TO 6-12 ..................................................... 103
APPENDIX B: THE FORMULAS OF THEOREM 6.6 ................................... 104
APPENDIX C: FOR COROLLARY 6.8 AND THEOREM 6.9 ........................ 107
APPENDIX D: ALGORITHM 6.21 IN pg ........................................................ 109
                                            vii


                            LIST OF ABREVIATIONS
ABSER    All Best Swap Edges w.r.t. RC
ABSEW   All Best Swap Edges w.r.t. W α,β
BS      Best Switch
BSE     Best Swap Edge
dp       distance-preserving
dh       distance-hereditary
𝑓𝐺′ -L  𝑓𝐺′ -adjacency list
MRCT   Minimum Routing Cost Spanning Tree
RC     Routing Cost
sdp    sequentially distance-preserving
ST     Spanning Tree
                                        viii


                            LIST OF SYMBOLS
𝑉(𝐺)       vertex set of 𝐺
𝐸(𝐺)       edge set of 𝐺
𝛿(𝐺)       minimum vertex degree of 𝐺
∆(𝐺)       maximum vertex degree of 𝐺
𝐺[𝑋]       subgraph of 𝐺 induced by 𝑋
𝐺𝑐         complement of 𝐺
𝑑𝐺 (𝑢, 𝑣) distance of 𝑢 and 𝑣 in 𝐺
𝑃𝑛         path of order 𝑛
𝐶𝑛         cycle of order 𝑛
𝑆𝑛         star graph of order 𝑛
𝐾𝑛         complete graph of order n
𝑊𝛼,𝛽 (𝐺)   generalized weighted total distance of 𝐺
𝐺𝐴\𝐵        mutaion of graph 𝐺 regarding 𝐴 and 𝐵
deg 𝐺 (𝑣)  vertex 𝑣’s degree in 𝐺
𝑃𝑘 (𝐴)     set of 𝑘-subsets of 𝐴
𝑃𝐺 (𝑢, 𝑣)  path between 𝑢 and 𝑣 in 𝐺
diam(𝐺)    diameter of 𝐺
≤          isometric subgraph
𝐷𝑡 (𝐺)     total distance of 𝐺
𝐷(𝐺)        average distance of 𝐺
𝑊(𝐺)       Wiener index of 𝐺
𝑊× (𝐺)     cross total distance of 𝐺
𝑊+ (𝐺)    plus total distance of 𝐺
𝑁𝐺 (𝑣)    neighborhood of 𝑣
𝑁𝐺 [v]    closed neighborhood of 𝑣
                                        ix


ℐ′               gradient of invariant ℐ
𝑓𝐺′ (𝑎𝑥
     ⃗⃗⃗⃗ )     discrete derivative of vertex 𝑎 toward neighbor 𝑥 regarding graph 𝐺.
∫𝑃 𝑓𝐺′ 𝑑𝐺      discrete integral of derivative through path 𝑃 in graph 𝐺
𝑇𝑣𝑢            component of 𝑇 − 𝑢𝑣 having the vertex 𝑣 for a tree 𝑇
  𝑘
𝑇𝑥𝑦            pseudotree made from tree 𝑇 with inset edge 𝑥𝑦 with cycle length 𝑘
 𝑥
𝑥𝑦𝑾            a vector related to pseudotree 𝑇𝑥𝑦𝑘
𝑥𝑦𝑾            a matrix related to pseudotree 𝑇𝑥𝑦 𝑘
𝑭𝑘            a matrix related to pseudotree 𝑇𝑥𝑦 𝑘
𝑫𝑘             a matrix related to pseudotree 𝑇𝑥𝑦 𝑘
𝑁𝐺𝑣 (𝑢)        relative neighborhood of 𝑢 compared to 𝑣 in 𝐺
⊚              Hadamard matrix product
[𝑎 ∧ 𝑽]        appending 𝑎 as the first entry of a vector 𝑉
𝑽[𝑖: 𝑗]       split of vector 𝑽 from index 𝑖 to 𝑗
𝑽[𝑖: ]        split of vector 𝑽 from index 𝑖 to end.
𝑽[: 𝑖]        split of vector 𝑽 from first to index 𝑖
𝑽[𝑖]          𝑖th entry of vector 𝑽
𝑨[𝑖: 𝑗, 𝑚: 𝑛] Split of matrix 𝑨 row from 𝑖 to 𝑗 column 𝑚 to 𝑛
                                                 x


CHAPTER 1: DEFINITIONS AND NOTATIONS
1.1 Basic Definitions
     Virtual networks are essential to our daily lives, and graphs are the most used
mathematical object for modeling them. Some networks are rapidly changing and
maintaining them is a matter of time. Graph theory definitions help to model a network.
Definitions and notations that are minimal, indicative, and uniform; help researchers
communicate more effectively and address problems faster. This section provides the rest
of the sections' general definitions, notations, and terminology. We cover concepts such
as distance, graph mutation, graph gradient, and graph invariants. Then we define the
swap edge of spanning trees, switch edge of trees, inset edge of graphs, and distance-
preserving graphs, as well as the problems we will work on in the following chapters. There
will be two more technical concepts, discrete integral and discrete derivative, for weighted
graphs, which this thesis defines for the first time. However, we postponed their definitions
and the relevant results until the following chapter. They serve as a natural gradient
descent on graphs, allowing us to avoid some intermediate tools such as ANN, significantly
reducing the time and space complexities of the problems.
     As the main resources: For chapters 2 and 4 see [18]. Chapter 3 and 5 see [19] and
[20], respectively. And chapter 6 is from [21] and [22].
     For a set 𝐴, 𝑃(𝐴) is the power set of 𝐴 and 𝑃𝑘 (𝐴) denotes the set of all 𝑘-subsets of
𝐴, 0 ≤ 𝑘 ≤ |𝐴|.
     A graph 𝐺 is an ordered pair with the notation 𝐺 = (𝑉(𝐺), 𝐸(𝐺)), where 𝑉(𝐺) is a set
known as the vertex set of 𝐺, and 𝐸(𝐺) is known as the edge set of 𝐺, a set generated by
a relation on 𝑉(𝐺) elements. An element of 𝑉(𝐺) or 𝐸(𝐺) is called a vertex or an edge,
                                                  1


respectively.
       A graph 𝐺 = (𝑉(𝐺), 𝐸(𝐺)) is a simple graph if 𝐸(𝐺) ⊆ 𝑃2 (𝑉(𝐺)). If 𝑥, 𝑦 ∈ 𝑉(𝐺) and
{𝑥, 𝑦} is an edge of 𝐺, we use 𝑥𝑦 ∈ 𝐸(𝐺) instead of {𝑥, 𝑦} ∈ 𝐸(𝐺). Moreover, we say 𝑥 and
𝑦 are adjacent if 𝑥𝑦 ∈ 𝐸(𝐺).
      The complement of a simple graph 𝐺 = (𝑉(𝐺), 𝐸(𝐺)) is denoted and defined as follows:
                                𝐺 𝑐 = (𝑉(𝐺), 𝑃2 (𝑉(𝐺)) − 𝐸(𝐺))
       The order of a graph is the cardinality of the vertex set, and its edge set's cardinality
is called the graph's size. A graph 𝐻 is called a subgraph of a graph 𝐺 and will be denoted
by 𝐻 ⊆ 𝐺 if 𝑉(𝐻) ⊆ 𝑉(𝐺) and 𝐸(𝐻) ⊆ 𝐸(𝐺).
      We assign real numbers using some functions to vertices or edges of a graph to make
a simple graph vertex-weighted, edge-weighted, or vertex and edge weighted (weighted).
We say a graph 𝐺 is (𝑓𝐺 , 𝑤𝐺 )-weighted if it is a weighted graph with a real-valued vertex
weight function 𝑓𝐺 and a real-valued edge weight function 𝑤𝐺 . (−, 𝑤𝐺 )-weighted or (𝑓𝐺 , −)-
weighted indicates vertices or edges of 𝐺 are not weighted, respectively. If the edges or
vertices are not assigned a weight, the weights are assumed to be one. For example, (𝑓𝐺 =
1, 𝑤𝐺 )-weighted or (𝑓𝐺 , 𝑤𝐺 = 1)-weighted in notation is equivalent to (−, 𝑤𝐺 )-weighted or
(𝑓𝐺 , −)-weighted, respectively. Also, (𝑓𝐺 > 0, 𝑤𝐺 > 0)-weighted says the relevant weight
functions are positive; the graph is positively weighted, etc. Using this notation for
consistency in this note, a non-weighted (simple) graph 𝐺 is (𝑓𝐺 = 1, 𝑤𝐺 = 1)-weighted or
(−, −)-weighted, that is, all weights are equal to 1.
      In graph 𝐺, a sequence of vertices 𝑣1 𝑣2 … 𝑣𝑛 = 𝑃𝐺 (𝑣1 , 𝑣𝑛 ), is a path between 𝑣1 , 𝑣𝑛 ∈
𝑉(𝐺), if 𝑣𝑖 𝑣𝑖+1 ∈ 𝐸(𝐺), 0 < 𝑖 < 𝑛. Then, two vertices are connected if there is a path
between them. Otherwise, they are disconnected. Similarly, a graph is called connected if
at least one path exists between every pair of vertices and is called disconnected; otherwise.
A maximal subset of pairwise connected vertices is called a component. Moreover, a graph
is 𝑘-edge connected if it remains connected if any 𝑟 < 𝑘 number of edges are removed
                                                 2


from the graph, 𝑘 ∈ ℕ. An edge is called a cut edge if removing the edge makes the graph
disconnected. In this thesis, unless it is clear from the content, a graph is assumed to be
connected.
    The length of a path 𝑃𝐺 (𝑣1 , 𝑣𝑛 ) = 𝑣1 𝑣2 … 𝑣𝑛 in a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 is
                                                      𝑛−1
                             𝑤𝐺 (𝑃𝐺 (𝑣1 , 𝑣𝑛 )) = ∑       𝑤𝐺 (𝑣𝑖 𝑣𝑖+1 ).
                                                      𝑖=1
     The distance between two connected vertices is the length of the paths, with the
minimum length between them. And it is infinite if they are disconnected. Moreover, the
distance of a vertex with itself is zero. For a graph 𝐺 and 𝑢, 𝑣 ∈ 𝑉(𝐺), 𝑑𝐺 (𝑢, 𝑣) denotes
the distance between 𝑢 and 𝑣. Note that the defined distance makes a metric space over
the set of vertices of a graph if and only if the edge weights are positive.
    The diameter of a graph 𝐺 is defined as follows:
                          diam(𝐺) = max{ 𝑑𝐺 (𝑢, 𝑣) | {𝑢, 𝑣} ⊆ 𝑉(𝐺) }.
    Accordingly diam(𝐺) = ∞ if 𝐺 is disconnected.
    The subgraph 𝐻 of a graph 𝐺 is isometric if the distances in 𝐻 remain unchanged,
that is
                           𝑑𝐻 (𝑢, 𝑣) = 𝑑𝐺 (𝑢, 𝑣),       ∀ {𝑢, 𝑣} ⊆ 𝑉(𝐻).
    If so, then we write 𝐻 ≤ 𝐺.
    A sequence 𝑣1 𝑣2 … 𝑣𝑛 𝑣1 is called a cycle in a graph 𝐺, if 𝑣1 𝑣2 … 𝑣𝑛 is a path and 𝑣1 𝑣𝑛 ∈
𝐸(𝐺), and its length equals the sum of the weight of the edges on the cycle.
    The total distance of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 is defined and denoted as follows:
                                   𝐷𝑡 (𝐺) =       ∑      𝑑𝐺 (𝑢, 𝑣).
                                              {𝑢,𝑣}⊆𝑉(𝐺)
                                                    3


     The Wiener index [1] of a connected simple graph 𝐺, 𝑊(𝐺), is equal to 𝐷𝑡 (𝐺), and
the Average distance [2,3] of a connected (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 on 𝑛 vertices is as
follows:
                                   𝐷𝑡 (𝐺)        𝑛 −1
                         𝐷(𝐺) =             =  (   ) ∑               𝑑𝐺 (𝑢, 𝑣).
                                     (𝑛2)        2        {𝑢,𝑣}⊆𝑉(𝐺)
     Definition 1.1: The cross total distance and the plus total distance of a (𝑓𝐺 , 𝑤𝐺 )-
weighted graph 𝐺 are defined as follows, respectively:
                           𝑊× (𝐺) =       ∑       [𝑓𝐺 (𝑢) × 𝑓𝐺 (𝑣)]𝑑𝐺 (𝑢, 𝑣),
                                      {𝑢,𝑣}⊆𝑉(𝐺)
                          𝑊+ (𝐺) =        ∑       [𝑓𝐺 (𝑢) + 𝑓𝐺 (𝑣)]𝑑𝐺 (𝑢, 𝑣).             ▲
                                      {𝑢,𝑣}⊆𝑉(𝐺)
     Using the above definitions, 𝑊𝛼,𝛽 (𝐺) = 𝛼 𝑊× (𝐺) + 𝛽 𝑊× (𝐺). For a given set of sources
𝑆 ⊆ 𝑉(𝐺), the routing cost (RC) of 𝑇 is equal to
                                 𝑅𝐶(𝐺, 𝑆) =          ∑       𝑑𝐺 (𝑢, 𝑣).
                                                (𝑎,𝑏)∈𝑉(𝐺)×𝑆
     One can see that 𝑊𝛼,𝛽 generalizes 𝑊× , 𝑊+ , 𝑊, 𝑅𝐶, 𝐷𝑡 , and 𝐷.
     We also define the 𝑘 𝑡ℎ power of the total distance of 𝐺 as follows
                𝑘
                  𝐷𝑡 (𝐺) =     ∑      𝑑𝐺𝑘 (𝑢, 𝑣),              𝑑 𝑘 (𝑢, 𝑣) = (𝑑(𝑢, 𝑣))𝑘 .
                           {𝑢,𝑣}⊆𝑉(𝐺)
     The neighborhood, closed neighborhood, and degree of 𝑣 ∈ 𝑉(𝐺) are denoted and
defined as follows, respectively.
                                 𝑁𝐺 (𝑣) = {𝑢 ∈ 𝑉(𝐺)|𝑢𝑣 ∈ 𝐸(𝐺)},
                                        𝑁𝐺 [𝑣] = 𝑁𝐺 (𝑣) ∪ {𝑣},
                                         deg 𝐺 (𝑣) = |𝑁𝐺 (𝑣)|.
                                                       4


     Using, let 𝛿(𝐺) = min{deg G (𝑣) | 𝑣 ∈ 𝑉(𝐺)} and ∆(𝐺) = max{deg G (𝑣) | 𝑣 ∈ 𝑉(𝐺)}.
Also, 𝐺 is called 𝑟-regular if deg 𝐺 (𝑣) = 𝑟, for every 𝑣 ∈ 𝑉(𝐺), 0 ≤ 𝑟 ≤ |𝑉(𝐺)|.
     The distance matrix [4] of a graph 𝐺 with 𝑉(𝐺) = {𝑣𝑖 }𝑛𝑖=1 denoted with 𝐷𝐺 , is an 𝑛 × 𝑛
matrix with the 𝑖𝑗th entry equal to 𝑑𝐺 (𝑣𝑖 , 𝑣𝑗 ). Thus,
                                  2. 𝐷𝑡 (𝐺) = ‖𝐷𝐺 ‖ = ∑ 𝑑𝑖𝑗 .
     Graphs 𝐺 and 𝐻 are isomorphic if there is a bijective, 𝜙 ∶ 𝑉(𝐺) ↔ 𝑉(𝐻) that preserves
the adjacency, that is, if 𝑥𝑦 ∈ 𝐸(𝐺) then 𝜙(𝑥)𝜙(𝑦) ∈ 𝐸(𝐻).
     Definition 1.2: A graph invariant is a map from all graphs to a set of arbitrary
objects (properties, numbers, etc.) that remains unchanged up to isomorphism between
the graphs. In other words, the map
                                            ℐ: 𝒢 ⟶ 𝒪
     from 𝒢 the set of all graphs, to 𝒪 the set of objects, is a graph invariant, if for the
isometric graphs 𝐺, 𝐻 ∈ 𝒢 we have ℐ(𝐺) = ℐ(𝐻).                                             ▲
     A perfect graph invariant ℐ is one in which if 𝐺, 𝐻 ∈ 𝒢 are not isomorphic, then ℐ(𝐺) ≠
 ℐ(𝐻). There is no known perfect graph invariant with a polynomial verification
complexity.
     Being Connected is a property base graph invariant. The average distance and Wiener
index are numerical graph invariants. The automorphisms group of graphs [5] is an
algebraic graph invariant. Also, 𝑊𝛼,𝛽 , 𝑊× , 𝑊+ , 𝑅𝐶, 𝑇𝐷 are distance-based numerical
graph invariants.
     A tree is a connected graph that does not have a cycle. It is known that 𝑇 is a tree if
and only if |𝐸(𝑇)| = |𝑉(𝑇)| − 1 and 𝑇 is connected. A vertex with degree one is called a
leaf. Here 𝑃𝑛 and 𝑆𝑛 denote 𝑛-vertex trees with two and 𝑛 − 1 leaves, respectively. And
𝐾𝑛 Denotes a complete graph on 𝑛 vertices, a graph that all vertices are adjacent. Figure
                                                  5


1.1 presents a 𝐾5 , a 𝑃5 , and a 𝑆8 from left to right, respectively.
                                   Figure 1.1 𝐾5 , a 𝑃5 , and a 𝑆8
    A spanning tree (ST) of a graph 𝐺 is a tree 𝑇 such that 𝑇 ⊆ 𝐺 and 𝑉(𝑇) = 𝑉(𝐺). Also,
𝐺[𝑆] denotes the induced subgraph of 𝐺 by 𝑆 ⊆ 𝑉(𝐺), where
                𝐺[𝑆] = ( 𝑆,      {𝑢𝑣 ∈ 𝐸(𝐺) | 𝑢, 𝑣 ∈ 𝑆} ) = (𝑉(𝐺[𝑆]), 𝐸(𝐺[𝑆])).
    Definition 1.3: A graph mutation is a change in the edge set of a graph.            ▲
    Note that a graph mutation does not change the vertex set of a graph. If 𝐺 is a graph,
we may add a set of edges 𝐴 to 𝐸(𝐺) and remove a set of edges 𝐵 from 𝐸(𝐺). If so, we
present the related mutation by 𝐴\𝐵 and the mutated graph with 𝐺𝐴\𝐵 that is
                                   𝐺𝐴\𝐵 = (𝑉(𝐺), 𝐸(𝐺) + 𝐴 − 𝐵).
    In a mutation 𝐴\𝐵 we may specify the scopes of 𝐴 and 𝐵. However, generally, the
scope of 𝐵 is a subset of 𝐸(𝐺) ∪ ∅, and the scope of A is a subset of 𝐸(𝐺 𝑐 ∪ 𝐺) ∪ ∅. The
added edge(s) are called inset edge(s), and the removed edge(s) are called extract edge(s).
In 𝐺𝐴\𝐵 if 𝐵 is empty for simplicity, we may use 𝐺𝐴 instead of 𝐺𝐴\∅ .
    Definition 1.4: Suppose 𝐺𝐴\𝐵 is a mutated graph, and ℐ is a numerical graph
invariant. We define the gradient of ℐ(𝐺) as follows:
                                  ℐ′ (𝐺A\𝐵 ) = ℐ(𝐺𝐴\𝐵 ) − ℐ(𝐺) .                        ▲
                                                  6


    1.2 Problems Statement
    By definition, graph invariants present a fixed description of a graph's nature.
Specifically, using a proper numerical graph invariant, we can have a frame from the
change of graph nature after a mutation.
     We will use the numerical distance-based graph invariants defined in the past section.
The average distance and Wiener index are some of the most studied graph invariants,
from molecular chemistry to social networks. Paraffin boiling point can be estimated by
the Wiener index of their atomic graph [1]. The average distance in a metabolic network
can be used to assess mass transfer efficiency [6].
    We will primarily focus on four problems related to graph mutation and distance-
based gradients, as detailed in the sections below. Graph gradients and related definitions
simplify our expressions and explanations. Most of our algorithms in the following chapters
for the problems are dynamic and very efficient. Moreover, the time complexity of our
algorithms for the problems depends on the exact topology of the input graphs and often
meets the minimal complexities. Since we bring detailed proofs, we do not need
experimental aid to prove our problem complexities. However, the algorithm for the last
relatively complicated problem is implemented on the pg platform in python.
    1.2.1 Best Swap Edge of Optimal Spanning Trees
    Suppose 𝑇 is an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 and 𝑆 ⊆ 𝑉(𝐺) is a set of sources.
Finding a minimum routing cost spanning tree (MRCT) is an 𝑁𝑃-Hard problem if |𝑆| > 1
and for |𝑆| = 1 is a polynomial time problem [7]. Therefore, when |𝑆| > 1, finding a new
MRCT once an MRCT link fails is costly. If an MRCT link fails, we will have two
components. Researchers propose replacing the broken link with an existing network link
that re-connects the components and minimizes the 𝑅𝐶 [8,9]. The replacement edge that
minimizes the 𝑅𝐶 is called a best swap edge (BSE) of the failed edge, w.r.t 𝑅𝐶. A BSE
w.r.t 𝑅𝐶 is indeed a mutation of 𝑇 that minimizes the gradient of 𝑅𝐶. We generalize BSEs
                                               7


w.r.t 𝑅𝐶.
     Definition 1.5: Suppose 𝑇 is an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 and ℐ is a
numerical graph invariant. If an edge 𝑒 ∈ 𝐸(𝑇) is removed and the two components of
𝑇 − 𝑒 reconnected with a new edge 𝜖 ∈ 𝐸(𝐺)\𝐸(𝑇) in a way that ℐ(𝑇 − 𝑒 + 𝜖) is minimized,
then 𝜖 is a best swap edge (BSE) of 𝜖 w.r.t ℐ. In our notation 𝜖 is a BSE of 𝑒 w.r.t ℐ if
                                     ℐ′(𝑇𝜖\𝑒 ) =     𝑚𝑖𝑛      ℐ′(𝑇𝑠\𝑒 ).                 ▲
                                                  𝑠∈𝐸(𝐺)\𝐸(𝑇)
     By definition,
               ℐ′(𝑇𝜖\𝑒 ) =     𝑚𝑖𝑛      ℐ′(𝑇𝑠\𝑒 ) ↔ ℐ(𝑇𝜖\𝑒 ) =         𝑚𝑖𝑛     ℐ(𝑇𝑠\𝑒 ).
                           𝑠∈𝐸(𝐺)\𝐸(𝑇)                             𝑠∈𝐸(𝐺)\𝐸(𝑇)
     Thus, we can use the above point for our invariants interchangeably.
      Problem 1: Let 𝑇 be an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 and 𝛼, 𝛽 ∈ ℝ. For each
                                                                          ′
𝑒 ∈ 𝐸(𝑇), find a BSE, 𝜖 ∈ 𝐸(𝐺)\𝐸(𝑇) w.r.t 𝑊𝛼,𝛽 and compute 𝑊𝛼,𝛽              (𝑇𝜖\𝑒 ).
     In another form:
     For each 𝑒 ∈ 𝐸(𝑇)
                                ′                           ′
           find 𝜖 such that 𝑊𝛼,𝛽   (𝑇𝜖\𝑒 ) =     𝑚𝑖𝑛      𝑊𝛼,𝛽 (𝑇𝑠\𝑒 )
                                              𝑠∈𝐸(𝐺)\𝐸(𝑇)
                              ′
            and compute 𝑊𝛼,𝛽     (𝑇𝜖\𝑒 ).
     We may call the problem all best swap edge w.r.t 𝑊𝛼,𝛽 (ABSEW).                      ▲
     To clarify, if 𝑒 is a cut edge of 𝐺, ABSEW should return ∞ as the value of
   𝑚𝑖𝑛      𝑊𝛼,𝛽 (𝑇𝑠\𝑒 ) and an arbitrary 𝑠 ∈ 𝐸(𝐺)\𝐸(𝑇), as a BSE of 𝑒. As mentioned, 𝑊𝛼,𝛽
𝑠∈𝐸(𝐺)\𝐸(𝑇)
is a generalization for all defined distance-based invariants. We may also discuss another
version of problem 1 where 𝑊𝛼,𝛽 is replaced with 𝑘𝐷𝑡 .
      There are some efficient algorithms that solve a particular version of problem 1 in
some limited situations [8,9]. Assume 𝐺 is a graph and 𝑆 is a set of sources. The mentioned
                                                     8


algorithms solve problem 1 w.r.t 𝑅𝐶, a specific case of 𝑊𝛼,𝛽 , when 𝐺 is positively edge-
weighted 2-edge-connected and only for |𝑆| = 𝑂(1) or |𝑉(𝐺)|. Where also do not calculate
the relevant 𝑅𝐶′𝑠.
      We solve problem 1 with no limit. Precisely, unlike the mentioned solutions, edge
weights can be any real numbers. The vertices will be weighted, and 𝑅𝐶 is generalized to
𝑊𝛼,𝛽 . In other words, |𝑆| will have no limit and can be any number from 1 to |𝑉(𝐺)|. The
                                                              ′
scope of the input graphs is any connected graph. And 𝑊𝛼,𝛽       of BSEs are calculated.
     Despite those, thanks to some fundamental concepts and related tools created in the
next chapter, our solution for problem 1 beats all existing solutions for variations of
problem 1. See chapter 3 for details.
1.2.2 Best Switch Edge of Trees
     Suppose 𝑇 is a (𝑓𝑇 , 𝑤𝑇 )-weighted tree. If 𝑒 ∈ 𝐸(𝑇) is removed, then 𝑇 − 𝑒 has two
components. We are interested to re-connect the components of 𝑇 − 𝑒 with an edge 𝜖 with
weight 𝑤, (𝜖 ∈ 𝐸(𝑇 𝑐 )) so that for a given 𝛼, 𝛽 ∈ ℝ, 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ) is minimized. As you see,
this is a specific version of BSE problem, where, for example, 𝐺 = 𝐾𝑛 and all 𝜖 ∈ 𝐸(𝑇 𝑐 ) =
𝐸(𝐺)\𝐸(𝑇) are equally weighted.
     Definition 1.6: Suppose 𝑇 is a (𝑓𝐺 , 𝑤𝐺 )-weighted tree, and ℐ is a graph invariant. If
an edge 𝑒 ∈ 𝐸(𝑇) is deleted a new edge 𝜖 ∈ 𝐸(𝑇 𝑐 ) with weight, 𝑤 is added to 𝑇 − e such
that ℐ(𝑇𝜖\𝑒 ) is minimum, then 𝜖 is a best switch (BS) of 𝜖 w.r.t ℐ. And the related mutation
𝜖\𝑒 or 𝑇𝜖\𝑒 is referred to as a switch. In notation, 𝜖 with weight 𝑤 is a BS of 𝑒 w.r.t ℐ if
                                  ℐ′(𝑇𝜖\𝑒 ) = 𝑚𝑖𝑛𝑐 ℐ′(𝑇𝑠\𝑒 ).                              ▲
                                             𝑠∈𝐸(𝑇 )
      Problem 2: Let 𝑇 be a (𝑓𝐺 > 0, 𝑤𝐺 > 0)-weighted tree. For given 𝑒 ∈ 𝐸(𝑇), 𝑤 > 0,
𝛼, 𝛽 ≥ 0 with 𝛼 + 𝛽 > 0 find a BS, 𝜖, w.r.t 𝑊𝛼,𝛽 and compute 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ), where 𝑤 =
𝑤𝑇𝜖\𝑒 (𝜖). In notation,
                                                9


     Get 𝑒 ∈ 𝐸(𝑇) 𝑤, 𝛼, 𝛽 ∈ ℝ≥0 (𝑤 > 0, 𝛼, 𝛽 ≥ 0, and 𝛼 + 𝛽 > 0)
                              ′                     ′
     Find 𝜖 such that 𝑊𝛼,𝛽      (𝑇𝜖\𝑒 ) = 𝑚𝑖𝑛𝑐 𝑊𝛼,𝛽    (𝑇𝑠\𝑒 ), 𝑤 = 𝑤𝑇𝜖\𝑒 (𝜖).                ▲
                                          𝑠∈𝐸(𝑇 )
     As a natural problem on trees, it is expected that there should be some efficient
solutions for some versions of the above problem. Using the top tree method [10,11,12],
solutions for specific versions of problem 2 with fixed parameters exist. We solve problem
2 for every possible input thanks to discrete integral and derivative. We can also update
the parameters during the algorithm with no more average complexity than the best
solutions. See chapter 4 for detail.
     1.2.3 Distance Preserving Graphs and 𝜹
     An 𝑛-vertex graph 𝐺 is distance-preserving (dp) if, for any integer 𝑘, 1 ≤ 𝑘 ≤ 𝑛, 𝐺
has at least one isometric subgraph of order 𝑘[13 ]. And 𝐺 is sequentially distance-
preserving (sdp) if there exists an ordering (𝑣1 , 𝑣2 , … , 𝑣𝑛 ) of 𝑉(𝐺) such that
𝐺\(𝑣1 , 𝑣2 , … , 𝑣𝑖 ) is isometric for each 𝑖, 1 ≤ 𝑖 ≤ 𝑛 [13]. If any connected induced subgraph
of 𝐺 is isometric, then 𝐺 is called distance-hereditary (dh)[15].
     Clearly, the dp property has the most relaxed condition among dh, sdp, and dp. That
help with more application in a dynamic network. Mutating a graph toward dh property
for an arbitrarily given graph might be computationally expensive in case of possibility.
That is because the dh graphs are very particular. In the case of dp, it can be much easier
regarding some results like the one below.
                                                                               2
     Proposition 1.1 [14]: Let 𝐺 be an 𝑛-vertex graph with 𝛿(𝐺) ≥ 3 𝑛 − 1. Then 𝐺 is
dp.                                                                                            ■
     However, proposition 1.1 bound is not necessary for being a dp graph, but it is simple
to verify. We want to determine whether the above bound can be lowered. That reduces
the required number of mutations that convert a graph to a dp graph. In this way, the
first step is the following result.
                                                      10


                                                                            𝑛
     Proposition 1.2 ([13,14]): For any integers 𝑛 ≥ 5, and 2 ≤ 𝑟 <           , where 𝑟 is even,
                                                                            2
there exists an 𝑟‐regular graph on 𝑛 vertices without any isometric subgraph of order 𝑛 −
1.                                                                                            ■
     On the other hand, there is a precise conjecture in [14] in response to the above result
that we will work on. It is a perfect min-degree criterion that confirms a graph is dp.
                                                              𝑛
     Problem 3: Let 𝐺 be an 𝑛‐vertex graph with 𝛿(𝐺) > 2 . Then 𝐺 is dp.                      ▲
     1.2.4 Inset Edge of Trees and Wiener Index
     If 𝐺 is a graph and the inset edge(s) 𝐴 ⊆ 𝑉(𝐺) are added to 𝐺, then we have the
mutation shown with 𝐺𝐴\∅ = 𝐺𝐴 . Predicting 𝑟, inset edges, which minimize the average
distance of a simple graph, is an 𝑁𝑃-Hard problem [2]. And it is a polynomial-time problem
when 𝑟 = 1. Suppose 𝑇 is a simple tree. Adding an edge to 𝑇 creates a unicyclic graph,
also known as pseudotree. We want to calculate and sort the average distance of all
psedutrees out of 𝑇. That is, calculate {𝐷(𝑇𝑒 )}𝑒∈𝐸(𝑇 𝑐) and sort it. It allows predicting the
link that lowers the average distance of the tree close to what we want. Note that 𝐷′ (𝑇𝑒 ) =
𝐷(𝑇𝑒 ) − 𝐷(𝑇). The main problem around is the following.
     Problem 4: For a tree 𝑇 compute and sort {𝐷′(𝑇𝑒 )}𝑒∈𝐸(𝑇 𝑐) .                             ▲
     We achieve some results on pseudotrees. Then we solve the above problem
dynamically in a complex recursive process. We establish some precise matrix tools and
strictly avoid extra calculations. In response, we will see that the solution is surprisingly
minimal on average, improving some outcomes regarding time complexities in [16]. We
also work to find the minimum in the set {𝐷′(𝑇𝑒 )}𝑒∈𝐸(𝑇 𝑐) . There is a heuristic approach for
that where 𝑇 is replaced with a connected graph [17]. But steel, our exact algorithm is
considerably faster for the case of trees. We implement the solution for problem 4.
                                               11


                                      REFERENCES
[1] H. Wiener, Structural determination of the paraffin boiling points, J. Am. Chem. Soc.,
     69 (1947), 17-20.
[2] A. Meyerson, B. Tagiku, Minimizing Average Shortest Path Distances via Shortcut Edge
     Addition, Approximation, randomization, and combinatorial optimization, Algorithms
     and techniques. 12th international workshop, APPROX 2009, and 13th international
     workshop, RANDOM 2009, Berkeley, CA, USA, (August 2009). Proceedings (pp.272-
     285)
[3] D. Bienstock, E. Györi, Average distance in graphs with removed elements, J. of graph
     theory, 12 (1988), 375-390.
[4] Robert W. Floyd, Algorithm 97: Shortest Path, Communications of the ACM 5 345
     (June 1962).
[5] Norman Biggs, Algebraic Graph Theory, Cambridge Mathematical Libr ary (2nd ed.),
     Cambridge University Press, (1993), Definition 2.1, p. 7.
[6] A. Drger, M. Kronfeld, M. J. Ziller, J. Supper, H. Planatscher, J.B. Magnus, M. Oldiges,
     O. Kohlbacher, A. Zell, Modeling metabolic networks in C. glutamicum: a comparison
     of rate laws in combination with various parameter optimization strategies", BMC Syst.
     Biol., 3 (2009).
[7] B. Y. Wu, Approximation algorithms for the optimal p-source communication spanning
     tree, Discrete App. Math., 143 (2004), 31-42.
[8] Davide Bilò1, Feliciano Colella, Luciano Gualà, Stefano Leucci, Guido Proietti, An
     Improved Algorithm for Computing All the Best Swap Edges of a Tree Spanner,
     Algorithmica, 82 (2020), 279-299.
[9] B. Y. Wu, C. -Y. Hsiao, Chao, K.-M.: The swap edges of a multiple-sources routing tree,
     Algorithmica, 50 (2008), 299-311.
[10] S. Alstrup, J. Holm, K. de Lichtenberg, M. Thorup, Maintaining information in fully
     dynamic trees with top trees, ACM Trans. Algorithm, 1 (2005), 243-264.
[11] S. Alstrup, J. Holm, M. Thorup, Maintaining center and median in dynamic trees, in:
     Proc. of the 8th Scandinavian Workshop on Algorithm Theory, (2000), 46-56.
                                               12


[12] Hung-Lung Wang, Maintaining centdians in a fully dynamic forest with top trees,
     Discrete App. Math., 181 (2015), 310-315.
[13] R. Nussbaum, Abdol-Hossein Esfahanian, Preliminary results on distance‐preserving
     graphs, Congressus Numerantium, 211 (2012), 141-149.
[14] R. Nussbaum, Distance‐Preserving Graphs, Ph.D. Thesis, Diss. Michigan State
     University, (2014).
[15] Hans-Jürgen Bandelt, Henry Martyn Mulder, Distance-hereditary graphs, J. Combin.
     Theory Ser. B, 41 (1986), 182-208
[16] Dennis Ross, Edge impact in graphs and social network matrix completion, Diss.
     Michigan State University, (2014).
[17] Nikos Parotsidis, Evaggelia Pitoura, Panayiotis Tsaparas, Selecting Shortcuts for a
     Smaller World, Proceedings of the 2015 SIAM International Conference on Data
     Mining, (2015), 28-36.
[18] M. H. Khalifeh, Abdol-Hossein, Discrete Integral and Discrete Derivative on Graphs
     and Switch problems of Trees, Mathematics, Advances in Graph Theory: Algorithms
     and Applications, 11 (2023), 1678.
[19] M. H. Khalifeh, Emad Zahedi, On a conjecture about the existence of isometric
     subgraphs, J. Graph Theory, 94 (2020), 299-302.
[20] M. H. Khalifeh, Abdol-Hossein Esfahanian, A Faster Algorithm for Finding Best Swap
     Edges of multiple-source Routing Tree, Netwotks, under review
[21] M. H. Khalifeh, Abdol-Hossein Esfahanian, Some results about the inset edge and
     average distance of trees, Disc. Appl. Math., 325 (2023), 186-199.
[22] M. H. Khalifeh, Abdol-Hossein Esfahanian, A Fast Algorithm for Sorting Inset Edges
     Effect On The Average Distance Of A Tree, submitted
                                              13


CHAPTER 2: DISCRET CALCULUS
    This brief section contains key notions that will be used in the two following chapters.
It helps to lower the time and space complexities of the relevant algorithms significantly.
    Consider 𝐺 to be a (𝑓𝐺 , 𝑤𝐺 )-weighted graph, 𝐴, 𝐵 ⊆ 𝑉(𝐺), and 𝑣 ∈ 𝑉(𝐺). We define
     𝑓𝐺 (𝐴) = ∑ 𝑓𝐺 (𝑥),          𝜎𝐺 (𝑣) = ∑ 𝑑𝐺 (𝑣, 𝑥) ,          ℎ𝐺 (𝑣) = ∑ 𝑓𝐺 (𝑥)𝑑𝐺 (𝑣, 𝑥),
                𝑥∈𝐴                         𝑥∈𝑉(𝐺)                        𝑥∈𝑉(𝐺)
                                     𝑑𝐺 (𝐴, 𝐵) = ∑ ∑ 𝑑𝐺 (𝑎, 𝑏).
                                                   𝑎∈𝐴𝑏∈𝐵
    In addition, for the given subgraphs 𝐻 and 𝐾 of 𝐺 let
               𝑑𝐺 (𝐻, 𝐾) =     ∑        ∑ 𝑑𝐺 (𝑢, 𝑣),              𝑓𝐺 (𝐻) = ∑ 𝑓𝐺 (𝑎).
                             𝑢 ∈ 𝑉(𝐻) 𝑣 ∈ 𝑉(𝐾)                             𝑎∈𝑉(𝐻)
    Definition 2.1: For a tree 𝑇 and 𝑢𝑣 ∈ 𝐸(𝑇), 𝑇 − {𝑢𝑣} has two components. We name
the components 𝑇𝑢𝑣 and 𝑇𝑣𝑢 with 𝑢 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑣 ∈ 𝑉(𝑇𝑣𝑢 ). As an extension for the later
                                                 𝑦
notation to subtrees, if 𝑥𝑦 ∈ 𝑉(𝑇𝑢𝑣 ), [𝑇𝑢𝑣 ] 𝑥 and [𝑇𝑢𝑣 ] 𝑦𝑥 denotes the components of 𝑇𝑢𝑣 − {𝑥𝑦}
and so on. Also, set 𝑛𝑇 (𝑇𝑢𝑣 ) = |𝑉(𝑇𝑢𝑣 )| and 𝑛𝑇 (𝑇𝑣𝑢 ) = |𝑉(𝑇𝑣𝑢 )|.                           ▲
    Using the above notations, 𝑉(𝑇) = 𝑉(𝑇𝑢𝑣 ) ∪ 𝑉(𝑇𝑣𝑢 ) and 𝑛𝑇 (𝑇𝑢𝑣 ) + 𝑛𝑇 (𝑇𝑣𝑢 ) = |𝑉(𝑇)|. In
plain language 𝑛𝑇 (𝑇𝑢𝑣 ) and 𝑛𝑇 (𝑇𝑣𝑢 ) are the number of vertices in 𝑇𝑢𝑣 and 𝑇𝑣𝑢 , respectively.
Also, 𝑓𝑇 (𝑇𝑢𝑣 ) and 𝑓𝑇 (𝑇𝑣𝑢 ) are the total weight of vertices in 𝑇𝑢𝑣 and 𝑇𝑣𝑢 , respectively.
                                                     14


    2.1 Discrete Derivative
    Definition 2.2: Suppose 𝐺 is a (𝑓𝐺 , 𝑤𝐺 )-weighted graph. The discrete derivative of a
vertex 𝑎 ∈ 𝑉(𝐺) toward a neighbor 𝑥 ∈ 𝑁𝐺 (𝑣) is defined and denoted as follows:
                                        𝑓𝐺 (𝑥) − 𝑓𝐺 (𝑎)
                                                                             𝑑𝐺 (𝑥, 𝑎) ≠ 0,
                                            𝑑𝐺 (𝑥, 𝑎)
                        𝑓𝐺′ (𝑎𝑥
                             ⃗⃗⃗⃗ ) =                                                               (2.1)
                                      { 𝑓𝐺 (𝑥) − 𝑓𝐺 (𝑎)                     𝑑𝐺 (𝑥, 𝑎) = 0.
    We say 𝑓𝐺′ is consistent if 𝑑𝐺 (𝑥, 𝑎) = 0 results in 𝑓𝐺′ (𝑎𝑥    ⃗⃗⃗⃗ ) = 0, 𝑎𝑥 ∈ 𝐸(𝐺).                   ▲
                          Figure 2.1 A weighted graph on five vertices
                                                           4−3   1
    Using the above image as graph 𝐺, 𝑓𝐺′ (a𝑥     ⃗⃗⃗⃗ ) =     = 3 where 𝑑𝐺 (𝑥, a) = 3. And 𝑓𝐺′ (𝑥a    ⃗⃗⃗⃗ ) =
                                                            3
3−4     1
 3
    = − 3.
    Lemma 2.3: Assume 𝑓1 an 𝑓2 are two vertex weight functions for a graph. If
𝑓 = 𝛼𝑓1 + 𝛽𝑓2 , then 𝑓 ′ = 𝛼𝑓1′ + 𝛽𝑓2′ , where 𝛼, 𝛽 ∈ ℝ. Moreover, if 𝑓1 an 𝑓2 are consistence,
then 𝑓 also is.                                                                                               ■
    A path 𝑣1 𝑣2 … 𝑣𝑛 is called 𝑓𝐺 -decreasing if it is a path and
                                       𝑓𝐺 (𝑣𝑖+1 ) < 𝑓𝐺 (𝑣𝑖 ),                               0 < 𝑖 < 𝑛.
    An 𝑓𝐺 -increasing path is defined in the same sense. Clearly, if 𝑣1 𝑣2 … 𝑣𝑛 is a 𝑓𝐺 -
decreasing path and edge weights are positive, then 𝑓𝐺′ (𝑣            𝑖 𝑣𝑖+1 ) < 0, 0 < 𝑖 < 𝑛.
                                                                   ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
                                                        15


     Definition 2.4: Suppose 𝐺 is a (𝑓𝐺 , 𝑤𝐺 )-weighted graph. Then, 𝑣 ∈ 𝑉(𝐺) is called 𝑓𝐺 -
Root or 𝑓𝐺 -Roof of 𝐺 if 𝑓𝐺 (𝑣) is minimum or maximum, respectively. Let 𝐴 ⊂ 𝑉(𝐺) is the
set of 𝑓𝐺 -Roots (𝑓𝐺 -Roofs) of 𝐺. Then we say 𝐺 is 𝑓𝐺 -convex (concave) if and only if for
every 𝑣 ∈ 𝑉(𝐺) there is a decreasing (increasing) path from 𝑣 to some 𝑎 ∈ 𝐴.                   ▲
     Whenever there is no confusion, we may use Root instead of, 𝑓𝐺 -Roots, etc. Using
figure 2.1, the vertex with weight 0 is a Root, and the vertex with weight 4 is a Roof in
the depicted graph.
     To employ discrete derivatives as a tool, we first create some induced weight functions
for the vertices using the current weight of the graph of an (𝑓𝐺 , 𝑤𝐺 )-weighted graph, 𝐺.
The first one is as follows:
                   𝜎𝐺 : 𝑉(𝐺) → ℝ          S. t.    𝜎𝐺 (𝑣) = ∑ 𝑑𝐺 (𝑣, 𝑥) ,          𝑣 ∈ 𝑉(𝐺)
                                                              𝑥∈𝑉(𝐺)
     Let 𝑇 be a (𝜎𝑇 , 𝑤𝑇 )-weighted tree (that is, the vertex-weight function is 𝜎𝑇 ). By
definition, if 𝑎𝑥 ∈ 𝐸(𝑇) and 𝑤𝐺 (𝑎𝑥) = 0, then 𝜎𝑇′ (𝑎𝑥  ⃗⃗⃗⃗ ) = 0, otherwise:
                            𝜎𝑇 (𝑥) − 𝜎𝑇 (𝑎) 𝜎𝑇 (𝑥) − 𝜎𝑇 (𝑎)
              𝜎𝑇′ (𝑎𝑥
                   ⃗⃗⃗⃗ ) =                  =                 = 𝑛𝑇 (𝑇𝑎𝑥 ) − 𝑛𝑇 (𝑇𝑥𝑎 ).     (2.2)
                                𝑑𝑇 (𝑥, 𝑎)        𝑤(𝑎𝑥)
     Because
                             𝜎𝑇 (𝑥) − 𝜎𝑇 (𝑎) = 𝑤(𝑎𝑥)[𝑛𝑇 (𝑇𝑎𝑥 ) − 𝑛𝑇 (𝑇𝑥𝑎 )].                (2.3)
     Another vertex-weight function for 𝐺 is induced using the primary weight functions
𝑓𝐺 as follows:
                  ℎ𝐺 : 𝑉(𝐺) → ℝ           S. t.   ℎ𝐺 (𝑣) = ∑ 𝑓𝐺 (𝑥)𝑑𝐺 (𝑣, 𝑥) ,          𝑣∈𝐺
                                                              𝑥∈𝑉(𝐺)
     To help with the computation of ℎ′𝑇 s for a (ℎ𝑇 , 𝑤𝑇 )-weighted tree 𝑇 let 𝑎 ∈ 𝑉(𝑇) and
𝑥 be an 𝑎’s neighbor. Thus,
                                                   16


               ℎ𝑇 (𝑎) =     ∑ 𝑓𝑇 (𝑣)𝑑 𝑇 (𝑎, 𝑣) + ∑ 𝑓𝑇 (𝑣)[𝑑 𝑇 (𝑥, 𝑣) + 𝑤(𝑎𝑥)],
                          𝑣∈𝑉(𝑇𝑎𝑥 )                 𝑣∈𝑉(𝑇𝑥𝑎 )
             ℎ𝑇 (𝑥) =      ∑ 𝑓𝑇 (𝑣)[𝑑𝑇 (𝑎, 𝑣) + 𝑤(𝑎𝑥)] + ∑ 𝑓𝑇 (𝑣)𝑑 𝑇 (𝑥, 𝑣).
                        𝑣∈𝑉(𝑇𝑎𝑥 )                               𝑣∈𝑉(𝑇𝑥𝑎 )
    Using the above equations
                           ℎ𝑇 (𝑥) − ℎ𝑇 (𝑎) = 𝑤(𝑢𝑣)[𝑓𝑇 (𝑇𝑎𝑥 ) − 𝑓𝑇 (𝑇𝑥𝑎 )].                          (2.4)
    Therefore, if 𝑤𝑇 (𝑎𝑥) = 0, then ℎ′𝑇 (𝑎𝑥  ⃗⃗⃗⃗ ) = 0, otherwise:
                       ℎ𝑇 (𝑥) − ℎ𝑇 (𝑎) 𝑤(𝑎𝑥)[𝑓𝑇 (𝑇𝑎𝑥 ) − 𝑓𝑇 (𝑇𝑥𝑎 )]
         ℎ′𝑇 (𝑎𝑥
              ⃗⃗⃗⃗ ) =                  =                                 = 𝑓𝑇 (𝑇𝑎𝑥 ) − 𝑓𝑇 (𝑇𝑥𝑎 ).  (2.5)
                           𝑑 𝑇 (𝑥, 𝑎)                𝑤(𝑎𝑥)
    According to equations 2.3 and 2.4; ℎ′𝑇 and 𝜎𝑇′ are consistent for any tree 𝑇. Based on
the facts stated above, we get the following results.
    Let     𝑁𝑇 = {(𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇)    and      𝐹𝑇 = {(𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) . Using
equations 2.2, 2.5, 𝐹𝑇 , and 𝑁𝑇 , one can compute 𝜎𝑇′ and ℎ′𝑇 easily. If 𝑓𝑇 (𝑣) = 1 for every
𝑣 ∈ 𝑉(𝑇), then (𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 )) = ((𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 )) for every 𝑢𝑣 ∈ 𝐸(𝑇). The following
algorithm extracts 𝐹𝑇 for a tree 𝑇, start with the edges adjacent to a leaf and then delete
the leaves at each step until the edge set is empty. It is linear regarding the number of
vertices and uses the fact that for every 𝑢𝑣 ∈ 𝐸(𝑇)
    𝑓𝑇 (𝑇𝑢𝑣 ) + 𝑓𝑇 (𝑇𝑣𝑢 ) = 𝑓𝑇 (𝑇),                 𝑓𝑇 (𝑇𝑣𝑢 ) = 𝑓𝑇 (𝑣) + ∑𝑥∈𝑁𝑇 (𝑣)\𝑢 𝑓𝑇 (𝑇𝑥𝑣 ).
Algorithm 2.5:
Input: Adjacency list of an 𝑛-vertex, nontrivial (𝑓𝑇 , 𝑤𝑇 )-weighted tree 𝑇 and 𝑓𝑇 (𝑇)
Output: 𝐹𝑇 = {(𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇)
    Initiate with 𝑆 = {𝑎 ∈ 𝑉(𝑇) | deg(𝑎) = 1}
                                                     17


           𝐖𝐡𝐢𝐥𝐞 (𝐸(𝑇) ≠ 𝜙)
                 𝐿𝑒𝑎𝑣𝑒𝑠 ← 𝑆
                𝑆=𝜙
                𝐅𝐨𝐫 𝑣 ∈ 𝑙𝑒𝑎𝑣𝑒𝑠
                     𝑢 ← 𝑁(𝑣)
                     (𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 )) ← (𝑓𝑇 (𝑇) − 𝑓𝑇 (𝑣), 𝑓𝑇 (𝑣))
                     𝑓𝑇 (𝑢)+= 𝑓𝑇 (𝑣)
                     𝐢𝐟 deg(𝑢) − 1 = 1. #Will be a leaf
                         𝑆 = 𝑆 ∪ {𝑢}
                     𝑇 = 𝑇 − {𝑣}              #Remove 𝑣 from adj list                              ■
       Corollary 2.6: For an 𝑛-vertex tree 𝑇, the sets, 𝑁𝑇 and, 𝐹𝑇 can be computed in 𝑂(𝑛)-
time.                                                                                              ■
       Assume 𝐺 is a (𝑓𝐺 , 𝑤𝐺 )-weighted graph with the adjacency list 𝐿. Sort 𝑁𝐺 (𝑎) according
to the values of 𝑓𝐺′ (𝑎𝑥    ⃗⃗⃗⃗ ), 𝑥 ∈ 𝑁𝑇 (𝑎), and update 𝐿 accordingly for each 𝑎 ∈ 𝑉(𝐺). The
updated 𝐿 is then called the 𝑓𝐺′ -adjacency list (𝑓𝐺′ -𝐿) of 𝐺. The sorting is set to ascending
order by default. By corollary 2.6 we have the following.
       Corollary 2.7: Let 𝑇 be a (𝑓𝑇 = 𝛼𝜎𝑇 + 𝛽ℎ𝑇 , 𝑤𝑇 )-weighted tree, 𝛼, 𝛽 ∈ ℝ, with 𝑛
vertices and an adjacency list, 𝐿. Then, the 𝑓𝑇′ -𝐿 of 𝑇 can be formed in
𝑂(∑𝑣∈𝑉(𝑇) deg (𝑣)log deg(𝑣))-time which is 𝑂(𝑛)-time on average.                                   ■
       The following result gives us an important fact about the weighted trees.
       Lemma 2.8: Suppose 𝑃 = 𝑣1 𝑣2 … 𝑣𝑛 , 𝑛 > 2, is a path in a (𝑓𝑇 , 𝑤𝑇 )-weighted tree 𝑇.
If 𝑤𝑇 > 0 and 𝜎𝑇′ (𝑣         1 𝑣2 ) ≥ 0, then 𝑣2 … 𝑣𝑛 is, 𝜎𝑇 -increasing. If 𝑓𝑇 > 0, 𝑤𝑇 > 0, and
                          ⃗⃗⃗⃗⃗⃗⃗⃗⃗
ℎ′𝑇 (𝑣  1 𝑣2 ) ≥ 0, then 𝑣2 … 𝑣𝑛+1 is, ℎ 𝑇 -increasing. If 𝑔𝑇 = 𝛼𝜎𝑇 + 𝛽ℎ 𝑇 , (for 𝛼, 𝛽 ∈ ℝ , 𝛼 + 𝛽 ≠
                                                                                          ≥0
     ⃗⃗⃗⃗⃗⃗⃗⃗⃗
0) 𝑓𝑇 > 0, 𝑤𝑇 > 0, and 𝑔𝑇′ (𝑣           1 𝑣2 ) ≥ 0, then 𝑣2 … 𝑣𝑛 is, 𝑔𝑇 -increasing.
                                     ⃗⃗⃗⃗⃗⃗⃗⃗⃗
       Proof: Assume 𝑇 is a (𝑓𝑇 , 𝑤𝑇 )-weighted tree and 𝑥𝑦𝑧 is a path in 𝑇. Without loss of
generality, we prove the lemma for 𝑥𝑦𝑧. We know that 𝑉(𝑇𝑢𝑣 ) ∪ 𝑉(𝑇𝑣𝑢 ) = 𝑉(𝑇) and 𝑉(𝑇𝑢𝑣 ) ∩
                                                          18


𝑉(𝑇𝑣𝑢 ) = ∅ for any 𝑢𝑣 ∈ 𝐸(𝑇). Thus, for some 𝐴 ⊂ 𝑉(𝑇),
                                                       𝑦
                                       𝑉(𝑇𝑦𝑧 ) = 𝑉(𝑇𝑥 ) ∪ {𝑦} ∪ 𝐴,                                                  (2.6)
       And
                                           𝑦
                                       𝑉(𝑇𝑧 ) = 𝑉(𝑇𝑦𝑥 ) − {𝑦} − 𝐴.                                                  (2.7)
       Therefore,
                                     𝑦                                      𝑦
                                 𝑉(𝑇𝑥 ) ⊂ 𝑉(𝑇𝑦𝑧 ) and 𝑉(𝑇𝑦𝑥 ) ⊃ 𝑉(𝑇𝑧 ).                                             (2.8)
       We use equations 2.2 and 2.5 for computing 𝜎𝑇′ and ℎ′𝑇 . Then by the assumption
                    𝑦                                                                                     𝑦
     ⃗⃗⃗⃗ ) = 𝑛𝑇 (𝑇𝑥 ) − 𝑛𝑇 (𝑇𝑦𝑥 ) ≥ 0. Thus by Eq. 2.6 𝜎𝑇′ (𝑦𝑧
𝜎𝑇′ (𝑥𝑦                                                                ⃗⃗⃗⃗ ) = 𝑛𝑇 (𝑇𝑦𝑧 ) − 𝑛𝑇 (𝑇𝑧 ) > 0. Since
𝑤𝑇 > 0, 𝑤(𝑦𝑧)𝜎𝑇′ (𝑦𝑧   ⃗⃗⃗⃗ ) > 0. That is, 𝜎𝑇 (𝑧) > 𝜎𝑇 (𝑦) which completes the proof for 𝜎𝑇 case.
                                            𝑦
Similarly, assume ℎ′𝑇 (𝑥𝑦    ⃗⃗⃗⃗ ) = 𝑓𝑇 (𝑇𝑥 ) − 𝑓𝑇 (𝑇𝑦𝑥 ) ≥ 0. If 𝑓𝑇 > 0, by Eq. 2.6 ℎ′𝑇 (𝑦𝑧         ⃗⃗⃗⃗ ) = 𝑓𝑇 (𝑇𝑦𝑧 ) −
        𝑦
𝑓𝑇 (𝑇𝑧 ) > 0. If, in addition 𝑤𝑇 > 0, then 𝑤(𝑦𝑧)ℎ′𝑇 (𝑦𝑧              ⃗⃗⃗⃗ ) > 0. Thus, by definition 2.2,
ℎ𝑇 (𝑧) > ℎ𝑇 (𝑦). That completes the proof for ℎ𝑇 case. The proof for the 𝑔𝑇′ case is like ℎ′𝑇
case. This completes the proof.                                                                                          ■
       Using lemma 2.8, we have the following result about the convexity of a tree.
       Theorem 2.9: Any positively edge-weighted tree is 𝜎-convex, and any positively
weighted tree is (𝛼𝜎 + 𝛽ℎ)-convex, for 𝛼, 𝛽 ∈ ℝ≥0.
       Proof: Let us have a positively edge-weighted tree with at least three vertices.
Assume a vertex, 𝑣1 , is not a 𝜎-Root and 𝑣1 𝑣2 … 𝑣𝑛 is the shortest possible path (in terms
of the number of edges) between 𝑣1 and a 𝜎-Root, 𝑣𝑛 . Assume toward a contradiction
that 𝑣1 𝑣2 … 𝑣𝑛 is not decreasing. Thus, suppose 𝑣𝑖 𝑣𝑖+1 is the first edge from 𝑣1 toward 𝑣𝑛 ,
such that 𝜎(𝑣𝑖 ) ≤ 𝜎(𝑣𝑖+1 ). Since the edge weights are positive, 𝜎 ′ (𝑣                    𝑖 𝑣𝑖+1 ) ≥ 0. Then, by
                                                                                         ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
lemma 2.8, the path 𝑣𝑖+1 𝑣𝑖+2 … 𝑣𝑛 is increasing. That is, 𝜎(𝑣𝑖 ) ≤ 𝜎(𝑣𝑛 ) and 𝑖 < 𝑛. If
𝜎(𝑣𝑖 ) = 𝜎(𝑣𝑛 ), 𝑣𝑖 also is a 𝜎- Root and 𝑣1 𝑣2 … 𝑣𝑖 is shorter than 𝑣1 𝑣2 … 𝑣𝑛 while having
the same specification, which is a contradiction with 𝑣1 𝑣2 … 𝑣𝑛 being the shortest. And if,
                                                           19


𝜎(𝑣𝑖 ) < 𝜎(𝑣𝑛 ), contradicts with, 𝑣𝑛 being a 𝜎-Root. Therefore, 𝑣1 𝑣2 … 𝑣𝑛 is decreasing.
Since 𝑣1 was arbitrary, the tree is 𝜎-convex. For the proof of 𝛼𝜎 + 𝛽ℎ case, use the same
strategy as for 𝜎, along with the positivity of the vertices’ weight.                                     ■
     Corollary 2.10: Assume that 𝑔 = 𝛼𝜎 + 𝛽ℎ, 𝛼, 𝛽 ∈ ℝ≥0 . Then, a positively weighted
tree has at most two 𝑔-Roots. If 𝑥 and 𝑦 are two 𝑔-Roots of a tree, then they are adjacent,
and 𝑔′ (𝑥𝑦             ⃗⃗⃗⃗ ) = 0. Moreover, if 𝑐 is, a tree’s 𝑔-Root and 𝑣 is a non-Root neighbor
         ⃗⃗⃗⃗ ) = 𝑔′ (𝑦𝑥
of 𝑐, then 𝑔′ (𝑐𝑣 ⃗⃗⃗⃗ ) > 0, and 𝑔′ (𝑣𝑐 ⃗⃗⃗⃗ ) < 0. Usefully, if 𝑃 = 𝑣1 𝑣2 … 𝑣𝑚 is a decreasing path
between 𝑣1 and a 𝑔-Root, 𝑣𝑚 , then 𝑔′(𝑣              𝑖 𝑎 ) < 0 if and only if 𝑎 = 𝑣𝑖+1 , 𝑖 < 𝑚. In addition,
                                                  ⃗⃗⃗⃗⃗
𝑃 is the longest 𝑔-decreasing path starting from 𝑣1 . Finally, a leaf is not a (𝛼𝜎 + 𝛽ℎ)-
Root of a positively weighted tree with more than 2 vertices.                                             ■
     By corollary 2.10, we have the following. For proof, see the appendix of this chapter.
     Lemma 2.11: Assume 𝑇 is a (𝑓𝑇 , 𝑤𝑇 > 0)-weighted tree, and we have 𝜎𝑇′ -𝐿. Then the
path between any pair 𝑎, 𝑏 ∈ 𝑉(𝑇), 𝑃𝑇 (𝑎, 𝑏), can be computed in the minimal time of
𝑂(|𝑃𝑇 (𝑎, 𝑏)|).                                                                                           ■
     Note that |𝑃𝑇 (𝑎, 𝑏)| refers to the number of edges on 𝑃𝑇 (𝑎, 𝑏).
     2.2 Discrete Integral
     Definition 2.12: Suppose 𝐺 is a (𝑓𝐺 , 𝑤𝐺 )-weighted graph. Regarding 𝑓𝐺′ and
𝑑𝐺 (distance function) we define and denote the discrete integral of 𝑓𝐺′ along a path
𝑃 = 𝑣1 𝑣2 … 𝑣𝑛 from 𝑣1 to 𝑣𝑛 as follows:
                                                      𝑛−1
                                   ∫ 𝑓𝐺′ 𝑑𝐺 = ∑            𝑓𝐺′ (𝑣  𝑖 𝑣𝑖+1 ). 𝑑𝐺 (𝑣𝑖 , 𝑣𝑖+1 ) .
                                                                ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                              ▲
                                    𝑃                 𝑖=1
     If 𝑎, 𝑏 ∈ 𝑉(𝐺) and 𝑃𝐺 (𝑎, 𝑏) is an arbitrary path between 𝑎 and 𝑏, we denote
∫𝑃𝐺(𝑎,𝑏) 𝑓𝐺′ 𝑑𝐺 as follows
                                                          𝑏
                                                       ∫ 𝑓𝐺′ 𝑑𝐺
                                                         𝑎
                                                             20


      By definitions 2.2 and 2.12, we have:
      Theorem 2.13: Suppose 𝐺 is a connected (𝑓𝐺 , 𝑤𝐺 )-weighted graph and 𝑎, 𝑏 ∈ 𝑉(𝐺).
If 𝑓𝐺′ is consistent, then for any path from 𝑎 to 𝑏
                                        𝑏
                                      ∫ 𝑓𝐺′ 𝑑𝐺 = 𝑓𝐺 (𝑏) − 𝑓𝐺 (𝑎).                                    ■
                                       𝑎
      Using figure 2.1 as graph 𝐺 with the given weights and the above result vs. definition
2.12, one can see that,
       𝑦
     ∫ 𝑓𝐺′ 𝑑𝐺 = ∫       𝑓𝐺′ 𝑑𝐺 = ∫        𝑓𝐺′ 𝑑𝐺 = ∫        𝑓𝐺′ 𝑑𝐺 = ∫       𝑓𝐺′ 𝑑𝐺 = ∫       𝑓𝐺′ 𝑑𝐺
      𝑥           𝑃=𝑥𝑎𝑦            𝑃=𝑥𝑎𝑏𝑦           𝑃=𝑥𝑎𝑐𝑏𝑦           𝑃=𝑥𝑐𝑏𝑦           𝑃=𝑥𝑐𝑎𝑦
                    =∫          𝑓𝐺′ 𝑑𝐺 = −2
                        𝑃=𝑥𝑐𝑎𝑏𝑦
                                                    21


                                               APPENDIX
      Proof of lemma 2.12: Without loss of generality, assume 𝑇 is a (𝑓𝑇 , 𝑤𝑇 = 1)-
weighted tree with at least three vertices, and we have 𝜎𝑇′ -𝐿. Then, by theorem 2.9, 𝑇 is
𝜎𝑇 -convex. So, there is a decreasing path, 𝑃𝑇 (𝑎1 , 𝑎𝑟 ) = 𝑎1 𝑎2 … 𝑎𝑟 , between any 𝑎1 ∈ 𝑉(𝑇)
and a 𝜎𝑇 - Root of 𝑇, say 𝑎𝑟 . By corollary 2.10, 𝜎𝑇′ (𝑎        ⃗⃗⃗⃗⃗𝑖 𝑠) < 0 if and only if 𝑠 = 𝑎𝑖+1 and in
addition 𝑃𝑇 (𝑎1 , 𝑎𝑟 ) is the longest possible decreasing path starting from 𝑎1 . We know that
the neighbors of a vertex in a 𝜎𝑇′ -𝐿 are sorted w.r.t. the values of 𝜎𝑇′ . Therefore, if 𝑐 is the
first neighbor of 𝑎𝑖 in a 𝜎𝑇′ -𝐿 and 𝜎𝑇′ (𝑎    ⃗⃗⃗⃗⃗𝑖 𝑐 ) < 0, then 𝑐 = 𝑎𝑖+1 , otherwise, 𝑎𝑖 = 𝑎𝑟 . Let
𝑥1 , 𝑦1 ∈ 𝑉(𝑇) and 𝑃𝑥 = 𝑥1 𝑥2 … 𝑥𝑚 and 𝑃𝑦 = 𝑦1 𝑦2 … 𝑦𝑛 be the paths connecting 𝑥1 and 𝑦1
and some 𝜎𝑇 -Roots, 𝑥𝑚 and 𝑦𝑛 . So, getting 𝑥1 , 𝑦1 , and 𝜎𝑇′ -𝐿 we can proceed toward 𝑥𝑚
and 𝑦𝑛 , vertex by vertex, with the cost of only one derivative per progress. To find
𝑃𝑇 (𝑥1 , 𝑦1 ) start with 𝑥1 and 𝑦1 and proceed with one vertex on 𝑃𝑥 , then proceed with one
vertex on 𝑃𝑦 , then one on 𝑃𝑥 and then one on 𝑃𝑦 and so on. But break the process once
the first common vertex is obtained. Also, if we reach a 𝜎𝑇 - Root on one of 𝑃𝑥 or 𝑃𝑦 , we
stop there and continue on the other until we either get a common vertex or a 𝜎𝑇 -Root is
obtained. If we get a common vertex, let the vertex be 𝑥𝑖 = 𝑦𝑗 , 1 ≤ 𝑖 ≤ 𝑚, 1 ≤ 𝑗 ≤ 𝑛. So,
𝑃𝑇 (𝑥1 , 𝑦1 ) = 𝑥1 … 𝑥𝑖 𝑦𝑗−1 … 𝑦1 . Clearly, |𝑃𝑇 (𝑥1 , 𝑦1 )| ≤ 2max{𝑖, 𝑗} ≤ 2|𝑃𝑇 (𝑥1 , 𝑦1 )|. That is, we
used no more than 2|𝑃𝑇 (𝑥1 , 𝑦1 )| derivatives to get the common vertex 𝑥𝑖 = 𝑦𝑗 . Thus, we
got 𝑃𝑇 (𝑥1 , 𝑦1 ) in 𝑂(|𝑃𝑇 (𝑥1 , 𝑦1 )|)-time. On the other hand, if 𝑃𝑥 and 𝑃𝑦 do not intersect, by
corollary 2.10, the two 𝜎𝑇 -Roots, 𝑥𝑚 and 𝑦𝑛 , are adjacent and 𝑃𝑇 (𝑥1 , 𝑦1 ) =
𝑥1 𝑥2 … 𝑥𝑚 𝑦𝑛 … 𝑦2 𝑦1 which has been obtained with less than 𝑚 + 𝑛 + |𝑚 − 𝑛| derivatives.
This completes the proof.                                                                                  ■
      Algorithm 2.14 for a resolution of the above proof.
Algorithm 2.14:
Input: A tree 𝑇 and 𝜎𝑇′ -𝐿 for 𝑤𝑇 = 1 (edge weights are all 1)
Output: Takes 𝑥1 , 𝑦1 ∈ 𝑉(𝑇) and returns 𝑃𝑇 (𝑥1 , 𝑦1 )
Initiate 𝑃𝑥 = 𝑥1 , 𝑃𝑦 = 𝑦1 , 𝑥𝑖 = 𝑥1 , 𝑦𝑗 = 𝑦1, 𝑆𝑡𝑜𝑝𝑋 = 1, 𝑆𝑡𝑜𝑝𝑌 = 1
                                                          22


𝑾𝒉𝒊𝒍𝒆 (𝑆𝑡𝑜𝑝𝑋 ≠ 0 𝐨𝐫 𝑆𝑡𝑜𝑝𝑌 ≠ 0)
    {    𝒊𝒇 𝑆𝑡𝑜𝑝𝑋 ≠ 0{
              𝒊𝒇 𝜎𝑇′ (𝑥     𝑖 𝑣 ) < 0,
                         ⃗⃗⃗⃗⃗⃗            # 𝑣 is the first neighbor in the list of 𝑥𝑖 in 𝜎𝑇′ -L
                      {𝑥𝑖+1 ← 𝑣
                                  𝑃𝑥 = 𝑃𝑥 + 𝑥𝑖+1
                                  𝑥𝑖 ← 𝑥𝑖+1
                    𝒊𝒇 𝑙𝑎𝑏𝑏𝑙𝑒(𝑥𝑖 ) == 𝑦 {                 # that is, 𝑃𝑥 intersects with 𝑃𝑦
                                    𝑓𝑖𝑟𝑠𝑡_𝑠ℎ𝑎𝑟𝑒 = 𝑥𝑖            # from 𝑃𝑥
                                     𝑏𝑟𝑒𝑎𝑘 }
                                    𝑙𝑎𝑏𝑙𝑒(𝑥𝑖 ) = 𝑥
                                  }
                               }
             𝒆𝒍𝒔𝒆
                        𝑆𝑡𝑜𝑝𝑋 = 0                              # that is, we reach a 𝜎𝑇 -Root
        𝒊𝒇 𝑆𝑡𝑜𝑝𝑌 ≠ 0{
            𝒊𝒇 𝜎𝑇′ (𝑦
                    ⃗⃗⃗⃗⃗⃗
                       𝑗 𝑣 ) < 0,           # 𝑣 is the first neighbor in the list of 𝑦𝑖 in 𝜎𝑇′ -L
                    { 𝑦𝑗+1 ← 𝑣
                      𝑃𝑦 = 𝑃𝑦 + 𝑦𝑗+1
                      𝑦𝑗 ← 𝑦𝑗+1
                      𝒊𝒇 𝑙𝑎𝑏𝑏𝑙𝑒(𝑦𝑗+1 ) == 𝑥 {               # that is 𝑃𝑦 intersects with 𝑃𝑥
                                 𝑓𝑖𝑟𝑠𝑡_𝑠ℎ𝑎𝑟𝑒 = 𝑦𝑗             # from 𝑃𝑦
                                 𝑏𝑟𝑒𝑎𝑘 }
                    𝑙𝑎𝑏𝑙𝑒(𝑦𝑗 ) = 𝑦
                           }
                    }
            𝒆𝒍𝒔𝒆
                          𝑆𝑡𝑜𝑝𝑌 = 0           }               # that is, we reach a 𝜎𝑇 -Root
                                                     23


𝒊𝒇 𝑓𝑖𝑟𝑠𝑡_𝑠ℎ𝑎𝑟𝑒 = 𝑥𝑖 from 𝑃𝑥
      𝒓𝒆𝒕𝒖𝒓𝒏 𝑃𝑥 + 𝑦𝑗−1 … 𝑦1               # 𝑃𝑥 intersects with 𝑃𝑦
𝒊𝒇 𝑓𝑖𝑟𝑠𝑡_𝑠ℎ𝑎𝑟𝑒 = 𝑦𝑗 from 𝑃𝑦
      𝒓𝒆𝒕𝒖𝒓𝒏 𝑥1 … 𝑥𝑖−1+ 𝑟𝑒𝑣𝑒𝑟𝑠𝑒 𝑜𝑓 𝑃𝑦     # 𝑃𝑦 intersects with 𝑃𝑥
                𝒓𝒆𝒕𝒖𝒓𝒏 𝑃𝑥 + 𝑟𝑒𝑣𝑒𝑟𝑠𝑒 𝑜𝑓 𝑃𝑦               # no common vertex ■
                                      24


CHAPTER 3: BEST SWAP EDGE OF OPTIMAL SPANNING TREES
      3.1 Introduction
      A network's survivability is its ability to recover communication if a network link
fails [12]. Techniques for addressing network survivability generally involve ST of the
network [2,3,7,10,15,16]. Given a network modeled as a graph 𝐺, the routing cost (RC) of
an ST of 𝐺 when a subset of nodes, say 𝑆, are used as sources is the total distances in the
tree from each source to all nodes in the network [20]. Finding a minimum routing cost
spanning tree (MRCT) is an 𝑁𝑃-Hard problem if |𝑆| > 1 [21]. When |𝑆| = 1, the problem
can be solved in polynomial time [21]. For more details and a survey on MRCT, see
[20,22,24]. Thus, for |𝑆| > 1, finding a new MRCT once an MRCT link fails is costly. If
an MRCT link fails, we will have two components. As a quick heuristic fix for the time-
sensitive networks, it is proposed that the broken link be replaced with an existing network
link that reconnects the components and minimizes the 𝑅𝐶 [5,23]. The replacement edge
that minimizes the 𝑅𝐶 was called a BSE of the failed edge w.r.t 𝑅𝐶 in chapter 1 and,
indeed, forms a mutation. In [5,23], some algorithms are provided to find a BSE for each
edge of an ST regarding 𝑅𝐶 (ABSER).
      Suppose 𝐺 is a positively edge-weighted and 2-edge-connected graph with 𝑚 edges
and 𝑛 vertices. Then, there is an 𝑂(𝑚. 2𝑂(𝛼(2𝑚,2𝑚)) . log 𝟐 𝑛 )-time algorithm for ABSER,
                                                        𝑘 𝑙𝑜𝑔𝛼(2𝑚,2𝑚))
where |𝑆| = 𝑂(1) or |𝑆| = 𝑛, and 𝑂(𝑚. 𝑘. 2𝑂(𝛼(2𝑚,2𝑚)                   . log 𝟐 𝑛 )-time otherwise
[5]. (The notation 𝛼(𝑛, 𝑛) denotes the inverse of the Ackermann function [1]). For ABSER,
there are also 𝑂(𝑚. log 𝑛 + 𝑛2 ) and 𝑂(𝑚𝑛) time algorithms where |𝑆| = 2 and |𝑆| > 2,
respectively [23]. All these solutions require that the graph be positively edge weighted.
By allowing the weight function to be arbitrary, we extend the ABSER problem and
                                                25


provide a computationally more efficient solution than the current techniques. Our
solution takes on average 𝑂((𝑚 − 𝑛). log 𝑛)-time and at best 𝑂(𝑚 − 𝑛)-time, with edge
weights that can be real ((+∞, −∞)) and 0 < |𝑆| ≤ 𝑛 (no restriction on |𝑆|). Moreover,
our algorithm works for some generalizations of 𝑅𝐶 as well, where the graphs are also
vertex weighted. See table 3.1 and the last section for more details. See [4,8,9,11,13,17] for
more information on BSE and ST problems.
    We indeed want to solve the following, introduced as problem 1 in chapter 1.
    For     each     𝑒 ∈ 𝐸(𝑇)   find  one     𝜖 ∈ 𝐸(𝐺)\𝐸(𝑇)    such     that    𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ) =
   𝑚𝑖𝑛      𝑊𝛼,𝛽 (𝑇𝑠\𝑒 ) and compute 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ).
𝑠∈𝐸(𝐺)\𝐸(𝑇)
    The problem was called “all best swap edges w.r.t 𝑊𝛼,𝛽 ” (ABSEW). Using the same
language, ABSER is defined as follows, where 𝑅𝐶(𝑇, 𝑆) = ∑(𝑎,𝑏)∈𝑉(𝑇)×𝑆 𝑑𝐺 (𝑢, 𝑣) is the RC
of 𝑇 for some given sources 𝑆 ⊆ 𝑉(𝑇).
    For     each     𝑒 ∈ 𝐸(𝑇)   find  one     𝜖 ∈ 𝐸(𝐺)\𝐸(𝑇)    such    that     𝑅𝐶(𝑇𝜖\𝑒 , 𝑆) =
   𝑚𝑖𝑛      𝑅𝐶(𝑇𝑠\𝑒 , 𝑆).
𝑠∈𝐸(𝐺)\𝐸(𝑇)
    We devise an algorithm for ABSEW with an average time of 𝑂((𝑚 − 𝑛). log 𝑛), a best
time of 𝑂(𝑚 − 𝑛), and a preprocessing time of 𝑂(𝑛), where there are 𝑚 edges and 𝑛
vertices. The algorithm takes up no more than 𝑂(𝑚)-space and works for any connected
weighted graph with real edge and vertex weight functions. For the cut edges, see the
explanation after the ABSEW definition at the end of this section. By showing that
ABSER is a subset of ABSEW, our algorithm outperforms ABSER’s existing algorithms
with no restrictions on the number of sources(|𝑆|), graph type, and edge weights. ABSEW
                                                26


also computes the 𝑅𝐶 of 𝑛 minimal trees of BSEs, whereas ABSER does not. The table
below compares the algorithms for ABSER.
                       Table 3.1 ABSER algorithms: Complexities Comparison
        Edges                                                       Prep      Source      Edge
                            Time Complexity for ABSER                                                 Graph Scope
     𝑛 Vertices                                                     Time    Number      Weights
            [5]’s
                           𝑂(𝑚. 2𝑂(𝛼(2𝑚,2𝑚)) . log 𝟐 𝑛 )            𝑂(𝑚) |𝑆| = 𝑂(1)      (0,+∞)     2-edge connected
     Algorithm
            [5]’s
                           𝑂(𝑚. 2𝑂(𝛼(2𝑚,2𝑚)) . log 𝟐 𝑛 )            𝑂(𝑚)     |𝑆| = 𝑛     (0,+∞)     2-edge connected
     Algorithm
            [5]’s
                     𝑂(𝑚. 𝑘. 2𝑂(𝛼(2𝑚,2𝑚)
                                         𝑘 𝑙𝑜𝑔𝛼(2𝑚,2𝑚))
                                                        . log 𝟐 𝑛 ) 𝑂(𝑚)     |𝑆| = 𝑘     (0,+∞)     2-edge connected
     Algorithm
           [23]’s
                                     𝑂(𝑚𝑛)                          𝑂(𝑛2 )   |𝑆| > 2     (0,+∞)     2-edge connected
     Algorithm
           [23]’s
                                𝑂(𝑚. log 𝑛 + 𝑛2 )                   𝑂(𝑛2 )   |𝑆| = 2     (0,+∞)     2-edge connected
     Algorithm
   Our    ABSEW                𝑂(𝑚 − 𝑛) (Best)
                                                                    𝑂(𝑛)   0 < |𝑆| ≤ 𝑛  (-∞,+∞)           Connected
   Algorithm                   𝑂((𝑚 − 𝑛). log 𝑛) (Av.)
     Problem 1 (ABSEW): Let 𝑇 be an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 and 𝛼, 𝛽 ∈
                                                                                                          ′
ℝ. For each 𝑒 ∈ 𝐸(𝑇), find a BSE, 𝜖 ∈ 𝐸(𝐺)\𝐸(𝑇) w.r.t 𝑊𝛼,𝛽 and compute 𝑊𝛼,𝛽                                  (𝑇𝜖\𝑒 ).
       For each 𝑒 ∈ 𝐸(𝑇)
                                               ′                                  ′
                  find 𝜖 such that 𝑊𝛼,𝛽           (𝑇𝜖\𝑒 ) =          𝑚𝑖𝑛       𝑊𝛼,𝛽  (𝑇𝑠\𝑒 )
                                                                  𝑠∈𝐸(𝐺)\𝐸(𝑇)
                                           ′
                   and compute 𝑊𝛼,𝛽            (𝑇𝜖\𝑒 ).
     We call the problem all best swap edge w.r.t 𝑊𝛼,𝛽 (ABSEW).                                                       ▲
     Note that if 𝑒 ∈ 𝐸(𝑇) is a cut edge of 𝐺, then                            𝑚𝑖𝑛      𝑊𝛼,𝛽 (𝑇𝑠\𝑒 ) = ∞. Thus, any
                                                                           𝑠∈𝐸(𝐺)\𝐸(𝑇)
𝜖 ∈ 𝐸(𝐺)\𝐸(𝑇) can be a BSE of 𝑒. Given that ABSEW should return ∞ as the value of
   𝑚𝑖𝑛        𝑊𝛼,𝛽 (𝑇𝑠\𝑒 ) and an arbitrary 𝑠 ∈ 𝐸(𝐺)\𝐸(𝑇), as a BSE of 𝑒.
𝑠∈𝐸(𝐺)\𝐸(𝑇)
                                                                  27


     3.2 Gradient of Swap Edges
     In this section, we will use chapter 2 results to develop an algorithm for ABSEW. The
first one says how to calculate the gradient of 𝑊× regarding a sawp edge mutation.
     Lemma 3.1: Assume that 𝑇 is an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 with 𝑢𝑣 ∈ 𝐸(𝑇)
and 𝑥𝑦 ∈ 𝐸(𝐺). If 𝑥 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑦 ∈ 𝑉(𝑇𝑣𝑢 ), then
                                                     𝑥                         𝑦
                    𝑊×′ (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑓𝐺 (𝑇𝑣𝑢 ) (∫ ℎ′𝑇𝑢𝑣 𝑑 𝑇𝑢𝑣 ) + 𝑓𝐺 (𝑇𝑢𝑣 ) (∫ ℎ′𝑇𝑣𝑢 𝑑 𝑇𝑣𝑢 )
                                                    𝑢                         𝑣
                                  +𝑓𝐺 (𝑇𝑣𝑢 )𝑓𝐺 (𝑇𝑢𝑣 )[𝑤𝐺 (𝑥𝑦) − 𝑤𝐺 (𝑢𝑣)].
     Proof: Assume we have the lemma assumptions. Then we can rewrite 𝑊× (𝑇) as
follows
   𝑊× (𝑇) = 𝑊× (𝑇𝑢𝑣 ) + 𝑊× (𝑇𝑣𝑢 ) + ∑               ∑ [𝑓𝐺 (𝑎)𝑓𝐺 (𝑏)][𝑑 𝑇 (𝑥, 𝑎) + 𝑤𝐺 (𝑥𝑦) + 𝑑 𝑇 (𝑏, 𝑦)]
                                        𝑎∈𝑉(𝑇𝑢𝑣 ) 𝑏∈𝑉(𝑇𝑣𝑢 )
            = 𝑊× (𝑇𝑢𝑣 ) + 𝑊× (𝑇𝑣𝑢 ) + 𝑓𝐺 (𝑇𝑣𝑢 )ℎ𝑇𝑢𝑣 (𝑥) + 𝑓𝐺 (𝑇𝑢𝑣 )ℎ𝑇𝑣𝑢 (𝑦) + 𝑤𝐺 (𝑥𝑦)𝑓𝐺 (𝑇𝑢𝑣 )𝑓(𝑇𝑣𝑢 ).
     Using the trick that 𝑊× (𝑇𝑢𝑣\𝑢𝑣 ) = 𝑊× (𝑇) and the above formula
           𝑊×′ (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑊× (𝑇𝑥𝑦\𝑢𝑣 ) − 𝑊× (𝑇)
                            = 𝑓𝐺 (𝑇𝑣𝑢 ) (ℎ 𝑇𝑢𝑣 (𝑥 ) − ℎ 𝑇𝑢𝑣 (𝑢)) + 𝑓𝐺 (𝑇𝑢𝑣 ) (ℎ 𝑇𝑣𝑢 (𝑦) − ℎ 𝑇𝑣𝑢 (𝑣))
                             + 𝑓𝐺 (𝑇𝑢𝑣 )𝑓𝐺 (𝑇𝑣𝑢 )(𝑤𝐺 (𝑥𝑦) − 𝑤𝐺 (𝑢𝑣)).
     In chapter 2, we saw that ℎ′𝑇𝑢𝑣 and ℎ′𝑇𝑣𝑢 are consistent. So we can use theorem 2.13 in
the above equation, that is
                                 𝑥                             𝑦
    𝑊×′ (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑓𝐺 (𝑇𝑣𝑢 ) (∫ ℎ′𝑇𝑢𝑣 𝑑𝑇𝑢𝑣 ) + 𝑓𝐺 (𝑇𝑢𝑣 ) (∫ ℎ′𝑇𝑣𝑢 𝑑 𝑇𝑣𝑢 )
                                𝑢                             𝑣
                 + 𝑓𝐺 (𝑇𝑣𝑢 )𝑓𝐺 (𝑇𝑢𝑣 )[𝑤𝐺 (𝑥𝑦) − 𝑤𝐺 (𝑢𝑣)].                                              ■
     We obtain the following lemma using a method like the proof of lemma 3.1.
                                                           28


      Lemma 3.2: Assume 𝑇 is an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺, 𝑢𝑣 ∈ 𝐸(𝑇), and 𝑥𝑦 ∈
𝐸(𝐺). If 𝑥 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑦 ∈ 𝑉(𝑇𝑣𝑢 ), then
                                             𝑥                              𝑦                                    𝑥
𝑊+′ (𝑇𝑥𝑦\𝑢𝑣 )         =     𝑛𝑇 (𝑇𝑣 ) (∫ ℎ′𝑇𝑢𝑣 𝑑𝑇𝑢𝑣 )
                                  𝑢
                                                        +  𝑛𝑇 (𝑇𝑢 ) (∫ ℎ′𝑇𝑣𝑢 𝑑 𝑇𝑣𝑢 )
                                                                  𝑣
                                                                                           + 𝑓𝐺 (𝑇𝑣 ) (∫ 𝜎𝑇′𝑢𝑣 𝑑 𝑇𝑢𝑣 )
                                                                                                       𝑢
                                           𝑢                               𝑣                                    𝑢
                                               𝑦
                           + 𝑓𝐺 (𝑇𝑢 ) (∫ 𝜎𝑇′𝑣𝑢 𝑑 𝑇𝑣𝑢 )
                                     𝑣
                                                          + [𝑛𝑇 (𝑇𝑣𝑢 )𝑓𝐺 (𝑇𝑢𝑣 )
                                              𝑣
                           + 𝑛𝑇 (𝑇𝑢𝑣 )𝑓𝐺 (𝑇𝑣𝑢 )][𝑤𝐺 (𝑥𝑦) − 𝑤𝐺 (𝑢𝑣)].                                                                    ■
                                                                                                                                      𝑦
      Lemma 3.3: Let 𝑇 be a (𝑓𝑇 , 𝑤𝑇 )-weighted tree and 𝑥𝑦 ∈ 𝐸(𝑇) with 𝑇 − {𝑥𝑦} = 𝑇𝑥 ∪
𝑇𝑦𝑥 . If we have {(𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 )), (𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) , we can calculate 𝜎𝑇′ 𝑦 and ℎ′𝑇 𝑦
                                                                                                                            𝑥           𝑥
                                                                         𝑦
on the path from 𝑥 toward any vertex of 𝑇𝑥 . A similar argument applies to the paths
from 𝑦 toward any vertex of 𝑇𝑦𝑥 .
                                                                                                                                    𝑦
      Proof: Suppose 𝑇 is a (𝑓𝑇 , 𝑤𝑇 )-weighted tree and 𝑥𝑦 ∈ 𝐸(𝑇) with 𝑇 − {𝑥𝑦} = 𝑇𝑥 ∪ 𝑇𝑦𝑥 .
                                                             𝑦
Also, suppose 𝑣1 𝑣2 … 𝑣𝑛 is a path in 𝑇𝑥 where 𝑣1 = 𝑥. Using equations 2.2 and 2.5 and
{(𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 )), (𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) we could extract 𝜎𝑇′ and ℎ′𝑇 through the edges
of 𝑣1 𝑣2 … 𝑣𝑛 . However, we require to get 𝜎𝑇′ 𝑦 and ℎ′𝑇 𝑦 through that path. To do so, one
                                                                     𝑥          𝑥
can check for the edges on 𝑣1 𝑣2 … 𝑣𝑛 that:
                    𝑦 𝑣                      𝑦 𝑣                𝑣                             𝑣
     (𝑛 𝑇 𝑦 ([𝑇𝑥 ]𝑣𝑖+1     𝑖
                              ), 𝑛 𝑇 𝑦 ([𝑇𝑥 ]𝑣𝑖𝑖+1 )) = (𝑛𝑇 (𝑇𝑣𝑖𝑖+1 )−𝑛𝑇 (𝑇𝑦𝑥 ), 𝑛𝑇 (𝑇𝑣𝑖+1     𝑖
                                                                                                    )),           0 < 𝑖 < 𝑛, (3.1)
          𝑥                         𝑥
                   𝑦 𝑣                       𝑦 𝑣               𝑣                                𝑣
    (𝑓𝑇 𝑦 ([𝑇𝑥 ]𝑣𝑖+1      𝑖
                             ), 𝑓 𝑇 𝑦 ([𝑇𝑥 ]𝑣𝑖𝑖+1 )) = (𝑓𝑇 (𝑇𝑣𝑖𝑖+1 ) − 𝑓𝑇 (𝑇𝑦𝑥 ), 𝑓𝑇 (𝑇𝑣𝑖+1      𝑖
                                                                                                       )) ,      0 < 𝑖 < 𝑛. (3.2)
         𝑥                         𝑥
      If 𝑤𝑇 (𝑣𝑖 𝑣𝑖+1 ) = 0, then by equations 2.1, 2.3, and 2.4 𝜎𝑇′ 𝑦 (𝑣                           ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗      ′
                                                                                                      𝑖 𝑣𝑖+1 ) = ℎ 𝑇 𝑦 (𝑣   𝑖 𝑣𝑖+1 ) = 0,
                                                                                                                         ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
                                                                                              𝑥                        𝑥
0 < 𝑖 < 𝑛. Otherwise, by equations 2.1, 2.2, 2.5, 3.1, and 3.2,
                                       𝑣                            𝑣
      𝜎𝑇′ 𝑦 (𝑣
             ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                 𝑖+1           𝑥              𝑖
               𝑖 𝑣𝑖+1 ) = 𝑛 𝑇 (𝑇𝑣𝑖 ) − 𝑛 𝑇 (𝑇𝑦 ) − 𝑛 𝑇 (𝑇𝑣𝑖+1 ) = 𝜎𝑇 (𝑣
                                                                              ′                             𝑥
                                                                                  𝑖 𝑣𝑖+1 ) − 𝑛 𝑇 (𝑇𝑦 ), 0 < 𝑖 < 𝑛, (3.3)
                                                                                ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
         𝑥
                                          𝑣                         𝑣
       ℎ′𝑇𝑦 (𝑣  ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                 𝑖+1         𝑥              𝑖
                  𝑖 𝑣𝑖+1 ) = 𝑓𝑇 (𝑇𝑣𝑖 ) − 𝑓𝑇 (𝑇𝑦 ) − 𝑓𝑇 (𝑇𝑣𝑖+1 ) = ℎ 𝑇 (𝑣
                                                                              ′                              𝑥
                                                                                    𝑖 𝑣𝑖+1 ) − 𝑓𝑇 (𝑇𝑦 ), 0 < 𝑖 < 𝑛. (3.4)
                                                                                 ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
           𝑥
                                                                        29


     That            is,          we              can         calculate              𝜎𝑇′ 𝑦            and       ℎ′𝑇 𝑦        using
                                                                                        𝑥                          𝑥
{(𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 )), (𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) .           Similarly,          we         can    achieve     symmetric
arguments and equations regarding 𝑦 and 𝑇𝑦𝑥 .                                                                                    ■
     Lemma 3.3 has a relevant corollary.
     Corollary 3.4: Let 𝑇 be a (𝑓𝑇 , 𝑤𝑇 )-weighted tree, 𝑢𝑣 ∈ 𝐸(𝑇), 𝑥 ∈ 𝑉(𝑇𝑢𝑣 ), and 𝑦 ∈
𝑉(𝑇𝑣𝑢 ). Then
       𝑥                   𝑥                                            𝑦                      𝑦
                                                                                                                           𝑦
     ∫   ℎ′𝑇𝑢𝑣 𝑑𝑇𝑢𝑣 =∫       ℎ′𝑇 𝑑 𝑇  − 𝑑 𝑇 (𝑢, 𝑥). 𝑓𝑇 (𝑇𝑦𝑥 ),       ∫    ℎ′𝑇𝑣𝑢 𝑑 𝑇𝑣𝑢 = ∫ ℎ′𝑇 𝑑𝑇 − 𝑑 𝑇 (𝑣, 𝑦). 𝑓𝑇 (𝑇𝑥 ),
      𝑢                  𝑢                                             𝑣                     𝑣
     And,
      𝑥                  𝑥                                              𝑦                      𝑦
                                                                                                                            𝑦
    ∫   𝜎𝑇′𝑢𝑣 𝑑 𝑇𝑢𝑣 =∫     𝜎𝑇′ 𝑑𝑇   − 𝑑 𝑇 (𝑢, 𝑥). 𝑛𝑇 (𝑇𝑦𝑥 ),         ∫    𝜎𝑇′𝑣𝑢 𝑑 𝑇𝑣𝑢 = ∫ 𝜎𝑇′ 𝑑𝑇 − 𝑑 𝑇 (𝑣, 𝑦). 𝑛𝑇 (𝑇𝑥 ).
     𝑢                  𝑢                                              𝑣                     𝑣
     Proof: Assume 𝑇 is a (𝑓𝑇 , 𝑤𝑇 )-weighted tree and 𝑢𝑣 ∈ 𝐸(𝑇) with 𝑇 − {𝑢𝑣} = 𝑇𝑢𝑣 ∪ 𝑇𝑣𝑢 .
If 𝑥 ∈ 𝑉(𝑇𝑢𝑣 ), 𝑦 ∈ 𝑉(𝑇𝑣𝑢 ), and 𝑃 𝑇𝑢𝑣 (𝑢, 𝑥) = 𝑢1 𝑢2 … 𝑢𝑛 (so 𝑢1 = 𝑢 and 𝑢𝑛 = 𝑥), then by the
definition of integral, lemma 3.3 Eq. 3.4, consistency of ℎ′𝑇𝑢𝑣 , and the fact that 𝑑 𝑇𝑣𝑢 = 𝑑 𝑇
on 𝑇𝑢𝑣 :
   𝑥                   𝑛−1                                                   𝑛−1
 ∫ ℎ′𝑇𝑢𝑣 𝑑 𝑇𝑢𝑣 = ∑           ℎ′𝑇𝑢𝑣 (𝑢  𝑖 𝑢𝑖+1 ). 𝑑 𝑇𝑢𝑣 (𝑢𝑖 , 𝑢𝑖+1 ) = ∑
                                    ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                                  (ℎ′𝑇 (𝑢                     𝑥
                                                                                            𝑖 𝑢𝑖+1 ) − 𝑓𝑇 (𝑇𝑦 )). 𝑑 𝑇 (𝑢𝑖 , 𝑢𝑖+1 )
                                                                                         ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
  𝑢                    𝑖=1                                                   𝑖=1
                           𝑥                              𝑛−1
                    = ∫ ℎ′𝑇 𝑑 𝑇 − 𝑓𝑇 (𝑇𝑦𝑥 ) ∑                 𝑑 𝑇 (𝑢𝑖 , 𝑢𝑖+1 ).
                          𝑢                               𝑖=1
     By definition of distance on 𝑇, ∑𝑛−1                𝑖=1 𝑑 𝑇 (𝑢𝑖 , 𝑢𝑖+1 ) = 𝑑 𝑇 (𝑢, 𝑥). Therefore,
                                          𝑥                 𝑥
                                      ∫     ℎ′𝑇𝑢𝑣 𝑑 𝑇𝑢𝑣 = ∫ ℎ′𝑇 𝑑 𝑇 − 𝑑𝑇 (𝑢, 𝑥). 𝑓𝑇 (𝑇𝑦𝑥 ).
                                        𝑢                  𝑢
     We proved the first equation. The proof of the other equations is identical.                                                ■
                                                                   30


     Definition 3.5: Suppose 𝐺 is an 𝑛-vertex graph with an ST, 𝑇. Then let
                   𝐶(𝑇𝑢𝑣 , 𝑇𝑣𝑢 ) = { 𝑥𝑦 ∈ 𝐸(𝐺)\{𝑢𝑣} | 𝑥 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑦 ∈ 𝑉( 𝑇𝑣𝑢 )} .                                ▲
     In addition, label the edges of 𝑇 arbitrarily from 1 to 𝑛 − 1, and let 𝑙(𝑒) denote the
label of 𝑒 ∈ 𝐸(𝑇), 1 ≤ 𝑙(𝑒) ≤ 𝑛 − 1. Now initiate a data structure of length 𝑛 − 1 named,
𝐸𝐿𝑇 , as follows:
                                       𝐸𝐿𝑇 = { (∅\𝑒,            ∞) | 𝑒 ∈ 𝐸(𝑇) } .
     With access to the 𝐸𝐿𝑇 values as follows: (We used current values as an example)
            𝐸𝐿𝑇 [𝑙(𝑒)] = (∅\𝑒, ∞),                   𝐸𝐿𝑇 [𝑙(𝑒)][2] = ∞,             𝐸𝐿𝑇 [𝑙(𝑒)][1] = ∅\𝑒.             ▲
     We may update the values of 𝐸𝐿𝑇 during our algorithm for ABSEW.
     Theorem 3.6: Let 𝑇 be an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺. Assume we have a
path 𝑃𝑇 (𝑣1 , 𝑣𝑠 ) = 𝑣1 𝑣2 … 𝑣𝑠 in 𝑇 with 𝑣1 𝑣𝑠 ∈ 𝐸(𝐺)\𝐸(𝑇) and each 𝑒 ∈ 𝐸(𝑇) has an
attached label, 𝑙(𝑒). Using 𝑤𝐺 (𝑣1 𝑣𝑠 ), and {(𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ) )}𝑢𝑣∈𝐸(𝑇) that is element-wise
                                                                                                               𝑠−1
linked   to     the edges;          we can      extract        {(𝑣𝑖 𝑣𝑖+1 , 𝑙(𝑣𝑖 𝑣𝑖+1 ), 𝑊×′ (𝑇𝑣1𝑣𝑠 \𝑣𝑖 𝑣𝑖+1 ))}𝑖=1   in
𝑂(|𝑃𝑇 (𝑣1 , 𝑣𝑠 )|)-time.
     Proof: Let us have the theorem’s assumption. By equations 2.1 and 2.5, and the
consistency of ℎ′𝑇 , ℎ′𝑇 (𝑎𝑥   ⃗⃗⃗⃗ ) = 𝑓(𝑇𝑎𝑥 ) − 𝑓(𝑇𝑥𝑎 ) or 0, 𝑎𝑥 ∈ 𝐸(𝑇). And using the discrete
integral definition
              𝑣𝑖+1               𝑣𝑖
            ∫      ℎ′𝑇 𝑑 𝑇 = ∫ ℎ′𝑇 𝑑𝑇 + ℎ′𝑇 (𝑣     𝑖 𝑣𝑖+1 ). 𝑑 𝑇 (𝑣𝑖 , 𝑣𝑖+1 ),
                                                ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                                 0 < 𝑖 < 𝑠.           (3.5)
             𝑣1                𝑣1
     Furthermore, as a result of definition 2.12 and theorem 2.13 for a tree, we have the
following general rules:
                                 𝑣𝑏                 𝑣𝑎
                             ∫ ℎ′𝑇 𝑑𝑇 = − ∫ ℎ′𝑇 𝑑 𝑇 ,                        1 ≤ 𝑎 ≤ 𝑏 ≤ 𝑠,                      (3.6)
                               𝑣𝑎                 𝑣𝑏
     and
                                                             31


                        𝑣𝑏                  𝑣𝑐                𝑣𝑐
                     ∫ ℎ′𝑇 𝑑 𝑇 + ∫ ℎ′𝑇 𝑑 𝑇 = ∫ ℎ′𝑇 𝑑 𝑇 ,                                  1 ≤ 𝑎 ≤ 𝑏 ≤ 𝑐 ≤ 𝑠.            (3.7)
                       𝑣𝑎                 𝑣𝑏                 𝑣𝑎
      Based on equations 3.5 and 3.7 and the discrete integral definition, the following
                                             𝑣
simple loop computes 𝐼𝑖 = ∫𝑣 𝑖 ℎ′𝑇 𝑑 𝑇 and 𝐷𝑖 = 𝑑 𝑇 (𝑣1 , 𝑣𝑖 ) for all 1 ≤ 𝑖 ≤ 𝑠.
                                              1
                         𝑣1
𝐈𝐧𝐢𝐭𝐢𝐚𝐭𝐞: 𝐼1 = ∫ ℎ′𝑇 𝑑𝑇 , 𝐷1 = 𝑑(𝑣1 , 𝑣1 ),                          𝑰 = {𝐼1 },        𝑫 = {𝐷1 }
                        𝑣1
𝐅𝐨𝐫 𝑣𝑗 𝑣𝑗+1 on 𝑃𝑇 (𝑣1 , 𝑣𝑠 ) from 𝑣1 𝑣2 𝐭𝐨 𝑣𝑠−1 𝑣𝑠 with the given order
        𝑖=𝑗
         𝑣𝑖+1
       ∫       ℎ′𝑇 𝑑𝑇 = 𝐼𝑖 + ℎ′𝑇 (𝑣        𝑖 𝑣𝑖+1 ). 𝑑 𝑇 (𝑣𝑖 , 𝑣𝑖+1 )
                                        ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                      and       𝑑 𝑇 (𝑣1 , 𝑣𝑖+1 ) = 𝐷𝑖 + 𝑤(𝑣𝑖 𝑣𝑖+1 )
        𝑣1
                     𝑣𝑖+1
       𝐼𝑖+1 ← ∫           ℎ′𝑇 𝑑𝑇                                          and       𝐷𝑖+1 ← 𝑑 𝑇 (𝑣1 , 𝑣𝑖+1 )
                   𝑣1
        𝑰 = 𝑰 ∪ {𝐼𝑖+1 }                                                    and       𝑫 = 𝑫 ∪ {𝐷𝑖+1 }
𝐞𝐧𝐝                                                                                                                        ▲
      With the given data from the theorem, the above loop’s time complexity is
𝑂(|𝑃𝑇 (𝑣1 , 𝑣𝑠 )|). Now using 𝑰, 𝑫, Equations 3.6 and 3.7, and corollary 3.4 very precisely
             𝑣1                                          𝑣𝑠               𝑣𝑠               𝑣𝑖+1
         ∫ ℎ′𝑇 𝑑 𝑇 = −𝐼𝑖                and            ∫     ℎ′𝑇 𝑑 𝑇 = ∫ ℎ′𝑇 𝑑 𝑇 − ∫            ℎ′𝑇 𝑑 𝑇 = 𝐼𝑠 − 𝐼𝑖+1 ,   (3.8)
           𝑣𝑖                                           𝑣𝑖+1             𝑣1              𝑣1
              𝑣1                            𝑣1
                                                                                𝑣                            𝑣
          ∫ ℎ′𝑇 𝑣𝑖+1 𝑑 𝑇 𝑣𝑖+1 = ∫ ℎ′𝑇 𝑑𝑇 − 𝑑 𝑇 (𝑣1 , 𝑣𝑖 ). 𝑓𝑇 (𝑇𝑣𝑖+1             𝑖
                                                                                    ) = −𝐼𝑖 + 𝐷𝑖 . 𝑓𝑇 (𝑇𝑣𝑖+1  𝑖
                                                                                                                ),      (3.9)
                    𝑣𝑖       𝑣𝑖
            𝑣𝑖                            𝑣𝑖
   𝑣𝑠                           𝑣𝑠
                                                                          𝑣
 ∫     ℎ′𝑇 𝑣𝑖   𝑑  𝑣
                  𝑇𝑣 𝑖
                          =∫        ℎ′𝑇 𝑑𝑇 − 𝑑 𝑇 (𝑣𝑖+1 , 𝑣𝑠 ). 𝑓𝑇 (𝑇𝑣𝑖𝑖+1 )
  𝑣𝑖+1    𝑣 𝑖+1     𝑖+1        𝑣𝑖+1
                                                                       𝑣
                          = 𝐼𝑠 − 𝐼𝑖+1 − (𝐷𝑠 − 𝐷𝑖+1 ). 𝑓𝑇 (𝑇𝑣𝑖𝑖+1 ).                                                    (3.10)
where 𝑣𝑖 𝑣𝑖+1 ∈ 𝑃𝑇 (𝑣1 , 𝑣𝑠 ), 0 ≤ 𝑖 ≤ 𝑠. Moreover, 𝑣1 𝑣𝑠 ∈ 𝐸(𝐺)\𝐸(𝑇) and 𝑣1 𝑣2 … 𝑣𝑠 being a
                                                     𝑣                       𝑣
path in 𝑇 implies that 𝑣1 ∈ 𝑉(𝑇𝑣𝑖𝑖+1 ) and 𝑣𝑠 ∈ 𝑉(𝑇𝑣𝑖+1                       𝑖
                                                                                  ), 0 ≤ 𝑖 ≤ 𝑠. Thus, by lemma 3.1
                                                                      32


                                                   𝑣1                                    𝑣𝑠
                                          𝑣𝑖                                    𝑣𝑖+1
            𝑊×′ (𝑇𝑣1𝑣𝑠 \𝑣𝑖 𝑣𝑖+1 )=   𝑓(𝑇𝑣𝑖+1 ) (∫ ℎ′𝑇 𝑣𝑖+1 𝑑 𝑇 𝑣𝑖+1 )   +   𝑓(𝑇𝑣𝑖 ) (∫ ℎ′𝑇 𝑣𝑖 𝑑 𝑇 𝑣𝑖 )
                                                            𝑣𝑖      𝑣𝑖                         𝑣𝑖+1   𝑣𝑖+1
                                                  𝑣𝑖                                    𝑣𝑖+1
                                         𝑣         𝑣
                                   +𝑓(𝑇𝑣𝑖𝑖+1 )𝑓(𝑇𝑣𝑖+1 𝑖
                                                          )(𝑤(𝑣1 𝑣𝑠 ) − 𝑤(𝑣𝑖 𝑣𝑖+1 )),       0 ≤ 𝑖 ≤ 𝑠.      (3.11)
     Thus, in 𝑂(𝑠 = |𝑃𝑇 (𝑣1 , 𝑣𝑠 )|)-time, we can compute what the theorem claims. In an
algorithmic view, the proof can be seen as follows. Accordingly, its total time complexity
is clearly 𝑂(|𝑃𝑇 (𝑣1 , 𝑣𝑠 )|).
Initiate 𝑊 = ∅, 𝑰, 𝑫, 𝑤(𝑣1 𝑣𝑠 )                                                   #in 𝑂(|𝑃𝑇 (𝑣1 , 𝑣𝑠 )|)
𝐅𝐨𝐫 𝑣𝑖 𝑣𝑖+1 ∈ 𝑃𝑇 (𝑣1 , 𝑣𝑠 )
      (𝑓𝑖 , 𝑓𝑖+1 ) ← Get (𝑓𝑇 (𝑇𝑣𝑣𝑖𝑖+1 ), 𝑓𝑇 (𝑇𝑣𝑣𝑖+1  𝑖
                                                          ))                      # Is given
      𝑙(𝑣𝑖 𝑣𝑖+1 ) ← Get 𝑙(𝑣𝑖 𝑣𝑖+1 )                                                # Is given
       𝑤 ← Get 𝑤𝐺 (𝑣𝑖 𝑣𝑖+1 )                                                       # Edge weight
              𝑣                                       𝑣
      𝐼 ← ∫𝑣 𝑖 ℎ′𝑇 𝑣𝑖+1 𝑑𝑇 𝑣𝑖+1 = −𝐼𝑖 + 𝐷𝑖 𝑓𝑇 (𝑇𝑣𝑖+1    𝑖
                                                           )                      #By Eq. 3.9 and 𝐼, 𝐷
               1    𝑣𝑖      𝑣𝑖
                 𝑣                                                        𝑣
      𝐼 𝑐 ← ∫𝑣 𝑠 ℎ′𝑇 𝑣𝑖 𝑑𝑇 𝑣𝑖        = 𝐼𝑠 − 𝐼𝑖+1 − (𝐷𝑠 − 𝐷𝑖+1 )𝑓𝑇 (𝑇𝑣𝑖𝑖+1 ) #By Eq. 3.10 and 𝐼, 𝐷
                 𝑖+1   𝑣𝑖+1     𝑣𝑖+1
       𝑊×′ (𝑇𝑣1𝑣𝑠 \𝑣𝑖 𝑣𝑖+1 ) = 𝑓𝑖+1 × 𝐼 + 𝑓𝑖 × 𝐼 𝑐 + 𝑓𝑖 × 𝑓𝑖+1 × (𝑤(𝑣1 𝑣𝑠 ) − 𝑤) #By Eq. 3.11
        𝑊 = 𝑊 ∪ (𝑣𝑖 𝑣𝑖+1 , 𝑙(𝑣𝑖 𝑣𝑖+1 ), 𝑊×′ (𝑇𝑣1𝑣𝑠 \𝑣𝑖 𝑣𝑖+1 ))
𝐞𝐧𝐝                                                                                                              ■
     The following result’s proof is quite similar to the theorem 3.6 proof.
     Corollary 3.7: Let 𝑇 be a 𝑆𝑇 of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺. Assume we have a path
𝑃𝑇 (𝑣1 , 𝑣𝑠 ) = 𝑣1 𝑣2 … 𝑣𝑠 in 𝑇 with 𝑣1 𝑣𝑠 ∈ 𝐸(𝐺)\𝐸(𝑇) and each 𝑒 ∈ 𝐸(𝑇) has an attached
label, 𝑙(𝑒). Using 𝑤𝐺 (𝑣1 𝑣𝑠 ) and {(𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 )), (𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) That is,
elements-wise            linked         to      the            relevant     edges;      we       can       extract
                                                𝑠−1
{(𝑣𝑖 𝑣𝑖+1 , 𝑙(𝑣𝑖 𝑣𝑖+1 ), 𝑊+′ (𝑇𝑣1𝑣𝑠 \𝑣𝑖 𝑣𝑖+1 ))}𝑖=1   , in 𝑂(|𝑃𝑇 (𝑣1 , 𝑣𝑠 )|)-time.                             ■
     By definition 1.1 and 1.4
              ′
           𝑊𝛼,𝛽   (𝐺𝐴\𝐵 ) = 𝑊𝛼,𝛽 (𝐺𝐴\𝐵 ) − 𝑊𝛼,𝛽 (𝐺) = 𝛼𝑊×′ (𝐺𝐴\𝐵 ) + 𝛽𝑊+′ (𝐺𝐴\𝐵 ), 𝛼, 𝛽 ∈ ℝ.
                                                                 33


     Thus, by theorem 3.6 and Corollary 3.7, we have the following.
     Corollary 3.8: Let 𝑇 be a 𝑆𝑇 of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺. Assume we have a path
𝑃𝑇 (𝑣1 , 𝑣𝑠 ) = 𝑣1 𝑣2 … 𝑣𝑠 in 𝑇 with 𝑣1 𝑣𝑠 ∈ 𝐸(𝐺)\𝐸(𝑇) and each 𝑒 ∈ 𝐸(𝑇) has an attached
label, 𝑙(𝑒). Using 𝑤𝐺 (𝑣1 𝑣𝑠 ) and {(𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 )), (𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) that is,
elements-wise            linked       to       the       relevant        edges;    we can   extract
                            ′                    𝑠−1
{(𝑣𝑖 𝑣𝑖+1 , 𝑙(𝑣𝑖 𝑣𝑖+1 ), 𝑊𝛼,𝛽 (𝑇𝑣1𝑣𝑠 \𝑣𝑖 𝑣𝑖+1 ))}𝑖=1 , in 𝑂(|𝑃𝑇 (𝑣1 , 𝑣𝑠 )|)-time.                ■
     3.3 All BSE Algorithm
     So far, the results have been based on the definitions of integral and derivative. The
following consequence uses past results to solve ABSEW in a technical way.
     Proposition 3.9: Assume 𝑇 is an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 with 𝑚 edges
and 𝑛 vertices. Apart from 𝑂(𝑛)-time preprocessing, ABSEW w.r.t. 𝑊𝛼,𝛽 can be solved in
an average time of 𝑂((𝑚 − 𝑛). log 𝑛) and the best time of 𝑂(𝑚 − 𝑛) within 𝑂(𝑚)-space.
     Proof: Let 𝑇 be an ST of 𝐺. And 𝐺 is a graph with arbitrary edge and vertex weights
that has 𝑚 edges and 𝑛 vertices. Also, let {𝐶𝑢𝑣 }𝑢𝑣∈𝐸(𝑇) is a set of initially empty variables.
First, we reversely extract 𝐶(𝑇𝑢𝑣 , 𝑇𝑣𝑢 ) for every 𝑢𝑣 ∈ 𝐸(𝑇) as follows:
A: For each 𝑥𝑦 ∈ 𝐸(𝐺)\𝐸(𝑇), find all 𝑢𝑣 ∈ 𝐸(𝑇) such that 𝑥𝑦 ∈ 𝐶(𝑇𝑢𝑣 , 𝑇𝑣𝑢 ), and add 𝑥𝑦 to
every relevant 𝐶𝑢𝑣 .
     Clearly, executing A results in 𝐶𝑢𝑣 = 𝐶(𝑇𝑢𝑣 , 𝑇𝑣𝑢 ) for each 𝑢𝑣 ∈ 𝐸(𝑇). One can see that
for 𝑥𝑦 ∈ 𝐸(𝐺)\𝐸(𝑇),
                                𝑥𝑦 ∈ 𝐶(𝑇𝑢𝑣 , 𝑇𝑣𝑢 ) if and only if 𝑢𝑣 ∈ 𝑃𝑇 (𝑥, 𝑦).
     So, we can update A and produce the same result as follows:
B: For each 𝑥𝑦 ∈ 𝐸(𝐺)\𝐸(𝑇), find 𝑃𝑇 (𝑥, 𝑦), then for each 𝑢𝑣 ∈ 𝑃𝑇 (𝑥, 𝑦) add 𝑥𝑦 to 𝐶𝑢𝑣 .
                                                           34


     Now label 𝐸(𝑇) and initiate 𝐸𝑙 𝑇 . We extend B as follows:
C: For each 𝑥𝑦 ∈ 𝐸(𝐺)\𝐸(𝑇), find 𝑃𝑇 (𝑥, 𝑦), then for each 𝑢𝑣 ∈ 𝑃𝑇 (𝑥, 𝑦), get 𝑙(𝑢𝑣), compute
𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ), add 𝑥𝑦 to 𝐶𝑢,𝑣 , and
     if 𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ) < 𝐸𝐿𝑇 [𝑙(𝑢𝑣)][1] then let 𝐸𝐿𝑇 [𝑙(𝑢𝑣)] ← (𝑥𝑦\𝑢𝑣, 𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 )).
     Thus, by completing C for every 𝑢𝑣 ∈ 𝐸(𝑇) we have 𝐸𝐿𝑇 [𝑙(𝑢𝑣)] = (𝜖\𝑢𝑣, 𝑊𝛼,𝛽 (𝑇𝜖\𝑢𝑣 ))
with 𝑊𝛼,𝛽 (𝑇𝜖\𝑢𝑣 ) =      𝑚𝑖𝑛        𝑊𝛼,𝛽 (𝑇𝑠\𝑢𝑣 ). Furthermore, for 𝑠 ∈ (𝐸(𝐺)\𝐸(𝑇))\𝐶(𝑇𝑢𝑣 , 𝑇𝑣𝑢 ),
                        𝑠∈𝐶(𝑇𝑢 ,𝑇𝑣 )
𝑊𝛼,𝛽 (𝑇𝑠\𝑢𝑣 ) = ∞. Therefore,           𝑚𝑖𝑛          𝑊𝛼,𝛽 (𝑇𝑠\𝑢𝑣 ) =    𝑚𝑖𝑛      𝑊𝛼,𝛽 (𝑇𝑠\𝑢𝑣 ). That is by
                                      𝑠∈𝐶(𝑇𝑢𝑣 ,𝑇𝑣𝑢 )                 𝑠∈𝐸(𝐺)\𝐸(𝑇)
executing B, 𝐸𝐿𝑇 [𝑙(𝑢𝑣)] = (𝜖\𝑢𝑣, 𝑊𝛼,𝛽 (𝑇𝜖\𝑢𝑣 ), where 𝜖 is a BSE of 𝑢𝑣 w.r.t 𝑊𝛼,𝛽 , 𝑢𝑣 ∈
𝐸(𝑇).
     By definition, 𝑊×′ (𝑇𝜖\e ) = 𝑊𝛼,𝛽 (𝑇𝜖\e ) − 𝑊𝛼,𝛽 (𝑇). So, we can update C as follows while
maintaining the same output for 𝐸𝐿𝑇 :
D: For every 𝑥𝑦 ∈ 𝐸(𝐺)\𝐸(𝑇), find 𝑃𝑇 (𝑥, 𝑦), then for each 𝑢𝑣 ∈ 𝑃𝑇 (𝑥, 𝑦): get 𝑙(𝑢𝑣),
              ′                                            ′
compute 𝑊𝛼,𝛽    (𝑇𝑥𝑦\𝑢𝑣 ), using 𝑊𝛼,𝛽 (𝑇) and 𝑊𝛼,𝛽           (𝑇𝑥𝑦\𝑢𝑣 ) compute 𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ), and
     if 𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ) < 𝐸𝐿𝑇 [𝑙(𝑢𝑣)][1]then let 𝐸𝐿𝑇 [𝑙(𝑢𝑣)] ← (𝑥𝑦\𝑢𝑣, 𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ))
     So, D is a solution to ABSEW.
     Finally, to devise an efficient ABSEW algorithm, in preprocessing, we label 𝐸(𝐺),
initiate 𝐸𝐿𝑇 , compute {(𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) , {(𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) , 𝐸(𝐺)\𝐸(𝑇),
and 𝑊𝛼,𝛽 (𝑇) using [14]. Then we set up an ABSEW algorithm, using D as follows. (Most
lines' complexities are presented to ease computing the total complexities.)
ABSEW Algorithm
Input: Adjacency lists of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 and an ST, 𝑇.
                                                                                  (𝑚, 𝑛) = (|𝐸(𝐺)|, |𝑉(𝐺)|)
Output: 𝐸𝐿𝑇
        = {∀ 𝑒 ∈ 𝐸(𝑇) a pair (𝜖\𝑒,             𝑊𝛼,𝛽 (𝑇𝜖\𝑒 )) with 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ) =        min     𝑊𝛼,𝛽 (𝑇𝑠\𝑒 ) }
                                                                                    𝑠∈𝐸(𝐺)\𝐸(𝑇)
                                                           35


Preprocessing-----------------------------------------------------------------------------------
Compute {(𝒇𝑻 (𝑻𝒗𝒖 ), 𝒇𝑻 (𝑻𝒖𝒗 ))}𝒖𝒗∈𝑬(𝑻)  linked to the edges             #𝑶(𝒏):Corollary 2.6
Compute {(𝒏𝑻 (𝑻𝒗𝒖 ), 𝒏𝑻 (𝑻𝒖𝒗 ))}𝒖𝒗∈𝑬(𝑻) linked to the edges              #𝑶(𝒏):Corollary 2.6
Sort        Adj list of 𝑻 ← 𝝈′𝑻 -L                             # 𝑶(𝒏) : Corollary 2.7
Compute     𝑾𝜶,𝜷 (𝑻)                                           # 𝑶(𝒏) : From [14]
Label       𝑬(𝑻)                                                # 𝑶(𝒏)
Initiate    𝑬𝑳𝑻                                                # 𝑶(𝒏) : Definition 3.5
Compute     𝑬(𝑮)\𝑬(𝑻)       \\ by traversing the ST            # 𝑶(𝒏)
Main (Executing D)---------------------------------------------------------------------------
For 𝒙𝒚 ∈ 𝑬(𝑮)\𝑬(𝑻)                       #𝑂(𝑚 − 𝑛) iteration(s)
    𝒘 ← 𝒘(𝒙𝒚)                           #For use in 2-
    1- Find 𝑨 = 𝑷𝑻 (𝒙, 𝒚)
                    #𝑂(|𝑃𝑇 (𝑥, 𝑦)|) = 𝑂(log 𝑛)-time on average: Lemma 2.11 & [18]
    2- Compute 𝑩 = {( 𝒖𝒗, 𝒍(𝒖𝒗), 𝑾′𝜶,𝜷 (𝑻𝒙𝒚\𝒖𝒗 ) )| 𝒖𝒗 ∈ 𝑷𝑻 (𝒙, 𝒚)}
                   #𝑂(|𝑃𝑇 (𝑥, 𝑦)|) = 𝑂(log 𝑛)-time on average: Corollary 3.8 & [18]
    For (𝒖𝒗, 𝒍(𝒖𝒗), 𝑾′𝜶,𝜷 (𝑻𝒙𝒚\𝒖𝒗 )) ∈ 𝑩
                   # 𝑂(|𝑃𝑇 (𝑥, 𝑦)| = |B|)=𝑂(log 𝑛) on average iterations,           [18]
          𝑾𝜶,𝜷 (𝑻𝒙𝒚\𝒖𝒗 ) = 𝑾′𝜶,𝜷 (𝑻𝒙𝒚\𝒖𝒗 ) + 𝑾𝜶,𝜷 (𝑻)                  # 𝑂(1)
          If 𝑾𝜶,𝜷 (𝑻𝒙𝒚\𝒖𝒗 ) < 𝑬𝑳𝑻 [𝒍(𝒖𝒗)][𝟐]                           # 𝑂(1)
                  𝑬𝑳𝑻 [𝒍(𝒖𝒗)] ← (𝒙𝒚\𝒖𝒗, 𝑾𝜶,𝜷 (𝑻𝒙𝒚\𝒖𝒗 )) #keeps min 𝑾𝜶,𝜷 (𝑻𝒙𝒚\𝒖𝒗 )
           end
     end
    Free 𝑨 and 𝑩
end
                                              36


     As we see, by following the average complexity of each line of the main algorithm, we
achieve an average time complexity of 𝑂((𝑚 − 𝑛). log 𝑛). It employs the adjacency lists
and the sets 𝐴, 𝐵, and 𝐸𝑙 𝑇 , which occupy no more than 𝑂(𝑚)-space. Furthermore, the
preprocessing takes 𝑂(𝑛)-time. Finally, if 𝑂(∑𝑥𝑦∈𝐸(𝐺)\𝐸(𝑇) |𝑃𝑇 (𝑥, 𝑦)| ⁄(𝑚 − 𝑛)) = 𝑂(1) or
𝑂(diam(𝐺)) = 𝑂(1) we clearly get algorithm’s best time, 𝑂(𝑚 − 𝑛). This completes the
proof.                                                                                              ■
     ABSEW algorithm requires 𝑂(𝑚)-space to store the graph's adjacency lists. We just
add 𝑂(𝑛)-space to initiate 𝐸𝐿𝑇 , which can still be lowered for graphs with cut edges. If 𝑒
is a cut edge, the ABSEW algorithm reflects this by keeping the initial values in 𝐸𝐿𝑇 that
is 𝐸𝐿𝑇 [𝑙(𝑒)] = (∅\𝑒, ∞). ABSEW algorithm’s average time for dense graphs or minimal
trees such as MRCT approaches its best, 𝑂(𝑚 − 𝑛). More precisely, the time complexity
of the ABSEW algorithm is exactly 𝑂(∑𝑢𝑣∈𝐸(𝐺)\𝐸(𝑇) |𝑃𝑇 (𝑢, 𝑣) |) that is taken from its
topology.
     3.4 Examples and ABSEW Algorithm for ABSER
     Assume 𝑇 is an ST of a (𝑓𝐺 , 𝑤𝐺 )-weighted graph 𝐺 and 𝑆 ⊆ 𝑉(𝐺) is a set of sources.
Set 𝑓𝐺 (𝑣) = 1 for every 𝑣 ∈ 𝑆 and 𝑓𝐺 (𝑣) = 0 for every 𝑣 ∈ 𝑉(𝐺)\𝑆. Then, 𝑊1,−1 (𝑇) =
𝑅𝐶(𝑇, 𝑆). Therefore, ABSER is a particular subset of the ABSEW algorithm. And ABSEW
solves ABSER for any connected real edge-weighted graph and any 1 ≤ |𝑆| ≤ 𝑛, where in
addition, computes the 𝑅𝐶 of the trees w.r.t. each BSE. That improves the current results
of ABSER algorithms in terms of time and constraints(sources count, edge weight limit,
graph type). Studies solve ABSER for 2-edge connected graphs with positive edge weights
                                                                    |𝑆| 𝑙𝑜𝑔𝛼(2𝑚,2𝑚))
[5,23]. In general, the solution in [5] takes 𝑂(𝑚. |𝑆|. 2𝑂(𝛼(2𝑚,2𝑚)                  . log 𝟐 𝑛 )-time,
with 𝑂(𝑚. 2𝑂(𝛼(2𝑚,2𝑚)) . log 𝟐 𝑛 )-time for |𝑆| = 𝑛 or 𝑂(1). Also, the solution of [23] takes
𝑂(𝑛2 + 𝑚. log 𝑛)-time for |𝑆| = 2, and 𝑂(𝑚𝑛)-time for |𝑆| > 2. Table 3.1 compares the
most recent algorithms.                                                                             ▲
                                                37


                                   ′
    Finally, because we compute 𝑊𝛼,𝛽 s in ABSEW, we guess that our solution has minimal
time complexity, which is precisely 𝑂[∑𝑢𝑣∈𝐸(𝐺)\𝐸(𝑇) |𝑃𝑇 (𝑢, 𝑣)|].
    Assume we have an ST as an MRCT or a minimal 𝑊𝛼,𝛽 of a graph.
    Problem 3.10: Is it possible to find a BSE w.r.t. 𝑊𝛼,𝛽 or RC for a single given failed
              (𝑚−𝑛)log 𝑛
edge in an 𝑂(            )-time?                                                        ▲
                  𝑛
    In addition, assume we run ABSEW or ABSER, and we have a set of BSEs. Then
    Problem 3.11: Is it possible to update BSEs w.r.t. 𝑊𝛼,𝛽 or RC in a polylogarithmic
time when a new single edge is added to the original graph?                             ▲
    Problem 3.12: Is it possible to update BSEs w.r.t. 𝑊𝛼,𝛽 or RC in a polylogarithmic
time when a single swap happens?                                                        ▲
                                            38


                                       REFERENCES
[1] W. Ackermann, Zum Hilbertschen Aufbau der reellen Zahlen., Math. Ann., 99 (1928),
     118-133.
[2] Christos Alexopoulos, Jay A. Jacobson, State space partition algorithms for stochastic
     systems with applications to minimum spanning trees, Networks, 35 (2000), 118-138.
[3] Julien Baste, Didem Gözüpek, Christophe Paul, Ignasi Sau, Mordechai Shalom, Dimitrios
     M. Thilikos, Parameterized complexity of finding a spanning tree with minimum reload
     cost diameter, Networks, 75 (2020), 259-277.
[4] Davide Bilò, Feliciano Colella, Luciano Gualà, Stefano Leucci, Guido Proietti, Effective
     edge-fault-tolerant single-source spanners via best (or good) swap edges, In Shantanu
     Das and Sébastien Tixeuil, editors, Structural Information and Communication
     Complexity - 24th International Colloquium, SIROCCO 2017, Porquerolles, France,
     June 19-22, 2017, Revised Selected Papers, volume 10641 of Lecture Notes in Computer
     Science, pp 303- 317. Springer, (2017).
[5] Davide Bilò, Luciano Gualà, Guido Proietti, Finding best swap edges minimizing the
     routing cost of a spanning tree, Algorithmica, 68 (2014), 337-357.
[6] Davide Bilò, Luciano Gualà, Guido Proietti, A faster computation of all the best swap
     edges of a shortest paths tree, Algorithmica, 73 (2015), 547-570.
[7] Sara Bourbour, Dinesh P. Mehta, William C. Navidi, Improved methods to compare
     distance metrics in networks using uniform random spanning trees, Networks, 75
     (2020), 402-413.
[8] Shantanu Das, Beat Gfeller, Peter Widmayer, Computing all best swaps for minimum-
     stretch tree spanners, J. Graph Algorithms Appl., 14 (2010), 287-306.
[9] P. Dunklemann, R. C. Entringer, Average distance, minimum degree and spanning
     trees, J. Graph Theory, 33 (2000), 1-13.
[10] Matteo Fischetti, Giuseppe Lancia, Paolo Serafini, Exact algorithms for minimum
     routing cost trees, Networks, 39 (2002), 161-173.
[11] Paola Flocchini, Linda Pagli, Giuseppe Prencipe, Nicola Santoro, Peter Widmayer,
     Computing all the best swap edges distributively, J. Parallel Distrib. Comput., 68
     (2008), 976-983.
                                               39


[12] M. Grotschel, C.L. Monma, and M. Stoer, Design of survivable networks, Handbook,
     in OR and MS, Vol.7, Elsevier, Amsterdam, (1995), 617-672.
[13] Giuseppe F. Italiano, Rajiv Ramaswami, Maintaining spanning trees of small diameter,
     Algorithmica 22, (1998), 275-304.
[14] M. H. Khalifeh, Abdol-Hossein Esfahanian, Discrete Integral and Discrete Derivative
     on Graphs and Switch problems of Trees, Mathematics, Advances in Graph Theory:
     Algorithms and Applications, 11 (2023), 1678.
[15] Masayuki Kobayashi, Yoshio Okamoto, Submodularity of minimum-cost spanning tree
     games, Networks, 63 (2014), 231-238.
[16] Seth Pettie, Sensitivity analysis of minimum spanning trees in sub-inverse-Ackermann
     time. In Proc. of the 16th Intl. Symposium on Algorithms and Computation, (2005),
     964-973.
[17] Aleksej Di Salvo, Guido Proietti, Swapping a failing edge of a shortest paths tree by
     minimizing the average stretch factor, Theor. Comput. Sci., 383 (2007), 23-33.
[18] Z. Shen, The average diameter of general tree structures, Comput. Math. Appl., 36
     (1998), 110-130.
[19] H. Wiener, Structural determination of Paraffin boiling points, J. Am. Chem. Soc., 69
     (1947), 17-20.
[20] B.Y. Wu, A polynomial time approximation scheme for the two-source minimum
     routing cost spanning trees, Journal of Algorithms, 44 (2002), 359-378.
[21] B.Y. Wu, Approximation algorithms for the optimal p-source communication spanning
     tree, Discrete App. Math., 143 (2004), 31-42.
[22] B.Y. Wu, K.-M. Chao, Spanning Trees and Optimization Problems, Chapman & Hall
     / CRC Press, 2004.
[23] B. Y. Wu, C. -Y. Hsiao, K.-M Chao, The swap edges of a multiple-sources routing tree,
     Algorithmica, 50 (2008), 299-311.
[24] B.Y. Wu, G. Lancia, V. Bafna, K.-M. Chao, R. Ravi, C.Y. Tang, A polynomial time
     approximation scheme for minimum routing cost spanning trees, SIAM J. on
     Computing, 29 (1999), 761-778.
                                               40


CHAPTER 4: BEST SWITCH EDGE OF TREES
     4.1 Introduction
     Unlike Euclidean space, which is equipped with coordinate systems, we cannot stay
at a network node and visualize where we are and how to achieve our goal. On the other
hand, analyzing a network using local information can lower the cost of tasks [1-6]. A
preprocessing may help to establish a network coordinate for local tasks and reach the
destination step by step.
     In this chapter, we work on problem 2 and two more problems based on it []. We use
discrete derivative, discrete integral, and convexity notions meaningfully to help with local
tasks.
     Let, 𝑁𝑇 = {(𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) and 𝐹𝑇 = {(𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) . Using the
notations, the coordinate of 𝑇 is shown and defined with
                                      𝑄𝑇 = {𝐹𝑇 , 𝑁𝑇 , 𝑊× (𝑇), 𝑊+ (𝑇)}.
     Now suppose 𝑇 is an 𝑛-vertex and positively weighted tree with coordinate 𝑄𝑇 . We
are interested in solving the following problem. Get 𝑇, 𝑄𝑇 , 𝑒 ∈ 𝐸(𝑇) and 𝑤, 𝛼, 𝛽 ∈ ℝ≥0 and
return 𝑇𝜖\𝑒 , 𝑄𝑇𝜖\𝑒 , 𝜖 and 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ), where 𝜖 is a BS of 𝑒 w.r.t. 𝑊𝛼,𝛽 and 𝑤 = 𝑤𝑇𝜖\𝑒 (𝜖).
Clearly, using the output of the problem, if we solve the problem with some complexities,
we can keep getting 𝑒𝑖 and 𝑤𝑖+1 , 𝛼𝑖+1 , 𝛽𝑖+1 ∈ ℝ≥0 and solve the problem on
((𝑇𝜖1\𝑒1 )𝜖2\𝑒2 … )𝜖𝑖 \𝑒𝑖 with the same complexities on 𝑇, 𝑖 > 1. We solve the problem with
the worst average time of 𝑂(log 𝑛) and the best average time of 𝑂(1). Changing edge
weights within the positive range are also supported in 𝑂(1)-time per change to update
the coordinates 𝑄𝑇𝜖 \𝑒 at any meaningful step. The problem can be seen as a generalization
                        𝑖 𝑖
of [7-9] that has found some applications [10-12,6]. For some relevant optimization
                                                   41


problems over spanning trees, see [13-19]. This chapter uses extensive notation for more
precise interaction, which may take some time to get used to. But our solutions are
natural, utilizing some calculus intuition behind the notations. See remark 4.8.
    We might be able to partially compare our solution for the above problem with top
tree methods [7-9]. See the last section. Generalizing top tree method solves the problem
above for some specified edges and fixed 𝛼, 𝛽 with the same average complexity as our
solution. But, by changing 𝛼, 𝛽, in the top tree method, one needs to repeat the
preprocessing, which is expensive. We also compare the solution with swap edge problem
of spanning trees [20,21, chapter 3], which requires a conversion. See the last section for
some more details. Problem 2, as mentioned, can be a specific version of ABSEW. Unlike
ABSEW, firstly, we want to find a BS for a single given edge, not all edges. Secondly, we
want to update the tree with a BS and be able to find a new BS after the update with
new parameters and without repeating the preprocessing.
    Based on the BS definition, we redefine problem 2 in an updated form as follows.
    Problem 2:
    Input:
    1. 𝑇,
    2. 𝑒 ∈ 𝐸(𝑇),
    3. 𝑤, 𝛼, 𝛽 ∈ ℝ≥0 , (𝑤, 𝛼, 𝛽 ∈ ℝ≥0 means 𝑤 > 0, 𝛼 + 𝛽 > 0, and 𝛼, 𝛽 ≥ 0).
    4. 𝑄𝑇 .
    Output:
    1. 𝜖 ∈ 𝐸(𝑇 𝑐 ), where 𝜖 is a BS of 𝑒 w.r.t. 𝑊𝛼,𝛽 with 𝑤𝑇𝜖\𝑒 (𝜖) = 𝑤.
    2. 𝑇𝜖\𝑒 ,
    3. 𝑄𝑇𝜖\𝑒 ,
    4. 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ).
                                                42


    As mentioned, according to the output, we can continue the algorithm for a new input
without needing fresh preprocessing. That is, we can keep getting 𝑒𝑖 and 𝑤𝑖+1 , 𝛼𝑖+1 , 𝛽𝑖+1 ∈
ℝ≥0 and solve the problem on ((𝑇𝜖1\𝑒1 )𝜖2\𝑒2 … )𝜖𝑖 \𝑒𝑖 within the same average time on 𝑇,
𝑖 ≥ 1. As output has fresh input information but a new edge that should be gotten.
    We also design the following problems for some comparison. They can be solved upon
solving problem 2.
    Problem 4.1:
    Input:
    1. 𝑇 with 𝐸(𝑇) = {𝑒𝑖 }𝑛𝑖=1 ,
    2. 𝑄𝑇
    3. {𝑤𝑖 , 𝛼𝑖 , 𝛽𝑖 ∈ ℝ≥0 }𝑛𝑖=1.
    Output:
    1. 𝑟,
    2. 𝜖𝑟 ∈ 𝐸(𝑇 𝑐 ),
    3. 𝑇𝜖𝑟 \𝑒𝑟 ,
    4. 𝑄𝑇𝜖𝑟\𝑒𝑟 ,
    5. 𝑊𝛼𝑟 ,𝛽𝑟 (𝑇𝜖𝑟 \𝑒𝑟 ),
    where 𝑊𝛼𝑟 ,𝛽𝑟 (𝑇𝜖𝑟 \𝑒𝑟 ) = 𝑚𝑖𝑛{𝑊𝛼𝑖 ,𝛽𝑖 (𝑇𝜖𝑖\𝑒𝑖 )}𝑛𝑖=1 and 𝜖𝑖 is a BS of 𝑒𝑖 w.r.t. 𝑊𝛼𝑖 ,𝛽𝑖 with
𝑤𝑖 = 𝑤𝑇𝜖 \𝑒 (𝜖𝑖 ). (Overall best switch).
          𝑖 𝑖
    Problem 4.2:
    Input:
    1. 𝑇 with 𝐸(𝑇) = {𝑒𝑖 }𝑛𝑖=1 ,
    2. 𝑄𝑇
    3. {𝑤𝑖 , 𝛼𝑖 , 𝛽𝑖 ∈ ℝ≥0 }𝑛𝑖=1.
                                                    43


     Output:
     1. {(𝜖𝑖 ∈ 𝐸(𝑇 𝑐 ), 𝑊𝛼𝑖 ,𝛽𝑖 (𝑇𝜖𝑖\𝑒𝑖 ))}𝑛𝑖=1 ,
     where 𝜖𝑖 is a BS of 𝑒𝑖 w.r.t. 𝑊𝛼𝑖 ,𝛽𝑖 with 𝑤𝑖 = 𝑤𝑇𝜖 \𝑒 (𝜖𝑖 ). (All best switches (ABS)).
                                                                                               𝑖    𝑖
     4.2 Main Algorithm for Switch and 𝑾𝜶,𝜷
     Lemma 4.3: Let 𝑇 be a (𝑓𝑇 , 𝑤𝑇 )-weighted tree, 𝑥𝑦 ∈ 𝐸(𝑇), and 𝑔𝑇 = 𝛼𝜎𝑇 + 𝛽ℎ𝑇 for
some 𝛼, 𝛽 ∈ ℝ. Using, 𝐹𝑇 and 𝑁𝑇 , we can calculate 𝑔𝑇′ 𝑦 on the path from 𝑥 toward any
                                                                                                    𝑥
                 𝑦
vertex of 𝑇𝑥 . A similar argument holds for a path from 𝑦 toward any vertex of 𝑇𝑦𝑥 .
                                                                                                                                        𝑦
     Proof: Let 𝑇 be a (𝑓𝑇 , 𝑤𝑇 )-weighted tree and 𝑥𝑦 ∈ 𝐸(𝑇) with 𝑇 − {𝑥𝑦} = 𝑇𝑥 ∪ 𝑇𝑦𝑥 and
                                                                                                             𝑦
𝑔𝑇 = 𝛼𝜎𝑇 + 𝛽ℎ𝑇 , 𝛼, 𝛽 ∈ ℝ. Assume 𝑣1 𝑣2 … 𝑣𝑛 is a path in 𝑇𝑥 , with 𝑣1 = 𝑥. Using equations
2.1, 2.2, 2.5, and {𝑁𝑇 , 𝐹𝑇 } = {(𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑢 )), (𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑢 ))}𝑢𝑣∈𝐸(𝑇) we could extract,
𝜎𝑇′ and ℎ′𝑇 , and so 𝑔𝑇′ = 𝛼𝜎𝑇′ + 𝛽ℎ′𝑇 . However, we need to get 𝑔𝑇′ 𝑦 through 𝑣1 𝑣2 … 𝑣𝑛 . To
                                                                                                                  𝑥
do so, one can check for 𝑣1 𝑣2 … 𝑣𝑛 ,
                       𝑦 𝑣                             𝑦 𝑣                   𝑣                                   𝑣
       (𝑛𝑇 𝑦 ([𝑇𝑥 ]𝑣𝑖+1      𝑖
                                  ), 𝑛 𝑇 𝑦 ([𝑇𝑥 ]𝑣𝑖𝑖+1 )) = (𝑛𝑇 (𝑇𝑣𝑖𝑖+1 )−𝑛𝑇 (𝑇𝑦𝑥 ), 𝑛𝑇 (𝑇𝑣𝑖+1                      𝑖
                                                                                                                       )),         0 < 𝑖 < 𝑛, (4.1)
            𝑥                               𝑥
                      𝑦 𝑣                             𝑦 𝑣                   𝑣                                    𝑣
       (𝑓 𝑇 𝑦 ([𝑇𝑥 ]𝑣𝑖+1     𝑖
                                  ), 𝑓 𝑇 𝑦 ([𝑇𝑥 ]𝑣𝑖𝑖+1 )) = (𝑓𝑇 (𝑇𝑣𝑖𝑖+1 ) − 𝑓𝑇 (𝑇𝑦𝑥 ), 𝑓𝑇 (𝑇𝑣𝑖+1                   𝑖
                                                                                                                      )).          0 < 𝑖 < 𝑛. (4.2)
            𝑥                              𝑥
     Thus, using equations 2.1, 2.2, and 2.5, along with 4.1 and 4.2:
       𝜎𝑇′ 𝑦 (𝑣  𝑖 𝑣𝑖+1 ) = 𝜎𝑇 (𝑣
              ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗              ′
                                               𝑖 𝑣𝑖+1 ) − 𝑛 𝑇 (𝑇𝑦 ),
                                            ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                 𝑥
                                                                                       ℎ′𝑇 𝑦 (𝑣                   ′
                                                                                                     𝑖 𝑣𝑖+1 ) = ℎ 𝑇 (𝑣
                                                                                                  ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                            𝑥
                                                                                                                         𝑖 𝑣𝑖+1 ) − 𝑓𝑇 (𝑇𝑦 ).
                                                                                                                      ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
          𝑥                                                                                 𝑥
     That is, using 𝐹𝑇 and 𝑁𝑇 , we can compute 𝑔𝑇′ 𝑦𝑥 (𝑣                                        𝑖 𝑣𝑖+1 ) as follows:
                                                                                             ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
                     𝑔𝑇′ 𝑦 (𝑣     𝑖 𝑣𝑖+1 ) = 𝛼𝜎𝑇 (𝑣
                               ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                ′                   ′
                                                                𝑖 𝑣𝑖+1 ) + 𝛽ℎ 𝑇 (𝑣
                                                             ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                                      𝑥
                                                                                    𝑖 𝑣𝑖+1 ) − 𝛼𝑛 𝑇 (𝑇𝑦 ) − 𝛽𝑓𝑇 (𝑇𝑦 ).
                                                                                 ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗                                      𝑥
                           𝑥
     Symmetrically, the argument holds for the 𝑇𝑦𝑥 and 𝑦 case.                                                                                    ■
                                                                               44


     The following lemma gives a clue between a BS of 𝑢𝑣 ∈ 𝑉(𝑇) w.r.t 𝑊𝛼,𝛽 and the 𝑝-
Roots and 𝑞-Roots of 𝑇𝑢𝑣 and 𝑇𝑣𝑢 . That is, often, finding a BS is equivalent to finding some
Roots.
     Lemma 4.4: Suppose 𝑇 is a (𝑓𝑇 , 𝑤𝑇 )-weighted tree with 𝑢𝑣 ∈ 𝐸(𝑇) and 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ).
If 𝑥 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑦 ∈ 𝑉(𝑇𝑣𝑢 ), then
                                    𝑥            𝑦
                ′
             𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 )   = ∫ 𝑝′𝑑   𝑇𝑢𝑣 + ∫ 𝑞′𝑑 𝑇𝑣𝑢 + 𝐹𝑁𝛼,𝛽 (𝑢𝑣)[𝑤𝑇𝑥𝑦\𝑢𝑣 (𝑥𝑦) − 𝑤𝑇 (𝑢𝑣)],
                                  𝑢            𝑣
     where,
     𝐹𝑁𝛼,𝛽 (𝑢𝑣) = [𝛼𝑓𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ) + 𝛽(𝑛𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ) + 𝑓𝑇 (𝑇𝑢𝑣 )𝑛𝑇 (𝑇𝑣𝑢 ))],    𝛼, 𝛽 ∈ 𝑅,
     And
           𝑝(𝑎) = [𝛼𝑓𝑇 (𝑇𝑣𝑢 ) + 𝛽𝑛𝑇 (𝑇𝑣𝑢 )]ℎ𝑇𝑢𝑣 (𝑎) + 𝛽𝑓𝑇 (𝑇𝑣𝑢 )𝜎 𝑇𝑢𝑣 (𝑎),            𝑎 ∈ 𝑉(𝑇𝑢𝑣 ),
           𝑞(𝑏) = [𝛼𝑓𝑇 (𝑇𝑢𝑣 ) + 𝛽𝑛𝑇 (𝑇𝑢𝑣 )]ℎ𝑇𝑣𝑢 (𝑏) + 𝛽𝑓𝑇 (𝑇𝑢𝑣 )𝜎 𝑇𝑣𝑢 (𝑏),            𝑏 ∈ 𝑉(𝑇𝑣𝑢 ).
     Proof: Assume 𝑇 is a tree. If we remove 𝑢𝑣 ∈ 𝐸(𝑇) and connect, 𝑇𝑢𝑣 and 𝑇𝑣𝑢 with 𝑥𝑦 ∈
𝐸(𝑇 𝑐 ), where 𝑥 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑦 ∈ 𝑉(𝑇𝑣𝑢 ), then
   𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑊𝛼,𝛽 (𝑇𝑢𝑣 ) + 𝑊𝛼,𝛽 (𝑇𝑣𝑢 )
                  + ∑           ∑ [𝛼𝑓𝑇 (𝑎)𝑓𝑇 (𝑏) + 𝛽(𝑓𝑇 (𝑎) + 𝑓𝑇 (𝑏))][𝑑 𝑇 (𝑥, 𝑎) + 𝑤𝑇𝑥𝑦\𝑢𝑣 (𝑥𝑦)
                    𝑎∈𝑉(𝑇𝑢𝑣 ) 𝑏∈𝑉(𝑇𝑣𝑢 )
                  + 𝑑 𝑇 (𝑏, 𝑦)]
= 𝑊𝛼,𝛽 (𝑇𝑢𝑣 ) + 𝑊𝛼,𝛽 (𝑇𝑣𝑢 ) + [𝛼𝑓𝑇 (𝑇𝑣𝑢 ) + 𝛽𝑛𝑇 (𝑇𝑣𝑢 )]ℎ𝑇𝑢𝑣 (𝑥) + [𝛼𝑓𝑇 (𝑇𝑢𝑣 ) + 𝛽𝑛𝑇 (𝑇𝑢𝑣 )]ℎ𝑇𝑣𝑢 (𝑦)
                + 𝛽[𝑓𝑇 (𝑇𝑣𝑢 )𝜎 𝑇𝑢𝑣 (𝑥) + 𝑓𝑇 (𝑇𝑢𝑣 )𝜎 𝑇𝑣𝑢 (𝑦)
                  +𝑤𝑇𝑥𝑦\𝑢𝑣 (𝑥𝑦)[𝛼𝑓𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ) + 𝛽(𝑛𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ) + 𝑓𝑇 (𝑇𝑣𝑢 )𝑓𝑇 (𝑇𝑢𝑣 ))](4.3)
     Using the fact that 𝑊× (𝑇𝑢𝑣\𝑢𝑣 ) = 𝑊× (𝑇) and the above formula,
                                                        45


       ′
    𝑊𝛼,𝛽  (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ) − 𝑊𝛼,𝛽 (𝑇)
                       = [𝑝(𝑥) − 𝑝(𝑢)] + [𝑞(𝑦) − 𝑞(𝑣)] + 𝐹𝑁𝛼,𝛽 (𝑢𝑣)[𝑤𝑇𝑥𝑦\𝑢𝑣 (𝑥𝑦) − 𝑤𝑇 (𝑢𝑣)].
     where 𝐹𝑁𝛼,𝛽 (𝑢𝑣) = [𝛼𝑓𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ) + 𝛽(𝑛𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ) + 𝑓𝑇 (𝑇𝑢𝑣 )𝑛𝑇 (𝑇𝑣𝑢 ))] and
                  𝑝(𝑎) = [𝛼𝑓𝑇 (𝑇𝑣𝑢 ) + 𝛽𝑛𝑇 (𝑇𝑣𝑢 )]ℎ𝑇𝑢𝑣 (𝑎) + 𝛽𝑓𝑇 (𝑇𝑣𝑢 )𝜎 𝑇𝑢𝑣 (𝑎),     𝑎 ∈ 𝑉(𝑇𝑢𝑣 ),
                  𝑞(𝑏) = [𝛼𝑓𝑇 (𝑇𝑢𝑣 ) + 𝛽𝑛𝑇 (𝑇𝑢𝑣 )]ℎ𝑇𝑣𝑢 (𝑏) + 𝛽𝑓𝑇 (𝑇𝑢𝑣 )𝜎 𝑇𝑣𝑢 (𝑏),    𝑏 ∈ 𝑉(𝑇𝑣𝑢 ).
     Since 𝑇𝑢𝑣 and 𝑇𝑣𝑢 are connected and 𝑝 and 𝑞 by lemma 2.3 and equations 2.3 and 2.4
are consistence; then by theorem 2.13 we have:
             ′                 𝑥             𝑦
         𝑊𝛼,𝛽     (𝑇𝑥𝑦\𝑢𝑣 ) = ∫𝑢 𝑝′𝑑𝑇𝑢𝑣 + ∫𝑣 𝑞′𝑑 𝑇𝑣𝑢 + 𝐹𝑁𝛼,𝛽 (𝑢𝑣)[𝑤𝑇𝑥𝑦\𝑢𝑣 (𝑥𝑦) − 𝑤𝑇 (𝑢𝑣)]          ■
     Lemma 4.5: Suppose 𝑇 is a positively weighted tree with at least three vertices and
𝑢𝑣 ∈ 𝐸(𝑇). If 𝑎 and 𝑏 are a 𝑝-Root of 𝑇𝑢𝑣 and a 𝑞-Root of 𝑇𝑣𝑢 , respectively, then a BS of
𝑢𝑣 w.r.t 𝑊𝛼,𝛽 is 𝑥𝑦 with 𝑥 ∈ 𝑁𝑇 [𝑎] and 𝑦 ∈ 𝑁𝑇 [𝑏]. More precisely, let the following be
vertex weight functions for the relevant vertices:
                    𝑝(𝑐) = [𝛼𝑓𝑇 (𝑇𝑣𝑢 ) + 𝛽𝑛𝑇 (𝑇𝑣𝑢 )]ℎ𝑇𝑢𝑣 (𝑐) + 𝛽𝑓𝑇 (𝑇𝑣𝑢 )𝜎 𝑇𝑢𝑣 (𝑐),   𝑐 ∈ 𝑉(𝑇𝑢𝑣 ),
                    𝑞(𝑐) = [𝛼𝑓𝑇 (𝑇𝑢𝑣 ) + 𝛽𝑛𝑇 (𝑇𝑢𝑣 )]ℎ𝑇𝑣𝑢 (𝑐) + 𝛽𝑓𝑇 (𝑇𝑢𝑣 )𝜎 𝑇𝑣𝑢 (𝑐),   𝑐 ∈ 𝑉(𝑇𝑣𝑢 ).
     Then a choice of 𝑥𝑦 as a BS of 𝑢𝑣 w.r.t 𝑊𝛼,𝛽 is as follows:
A: If (𝑢, 𝑣) = (𝑝-Root of 𝑇𝑢𝑣 , 𝑞-Root of 𝑇𝑣𝑢 ),
     (𝑥, 𝑦) = (𝑢, 𝑧) where 𝑞(𝑧) =            𝑚𝑖𝑛 𝑞(𝑐), or
                                           𝑐∈𝑁𝑇𝑢 (𝑣)
                                               𝑣
     (𝑥, 𝑦) = (𝑧, 𝑣) where 𝑝(𝑧) =            𝑚𝑖𝑛 𝑝(𝑐 ).
                                           𝑐∈𝑁𝑇𝑣 (𝑢)
                                               𝑢
     If 𝑞 ′ (𝑣𝑧                  ⃗⃗⃗⃗ )𝑤𝑇 (𝑢𝑧), 1 gives a choice for 𝑥𝑦; otherwise, 2.
             ⃗⃗⃗⃗ )𝑤𝑇 (𝑣𝑧) < 𝑝′ (𝑢𝑧
B: If (𝑢, 𝑣) ≠ (𝑝-Root of 𝑇𝑢𝑣 , 𝑞-Root of 𝑇𝑣𝑢 ), then (𝑥, 𝑦) = (𝑝-Root of 𝑇𝑢𝑣 , 𝑞-Root of 𝑇𝑣𝑢 ).
     Moreover, 𝐹𝑇 = 𝐹𝑇 𝑥𝑦\𝑢𝑣 and 𝑁𝑇 = 𝑁𝑇 𝑥𝑦\𝑢𝑣 except for the edges on 𝑃𝑇 (𝑢, 𝑥) and
𝑃𝑇 (𝑣, 𝑦). More precisely, if 𝑃 𝑇𝑢𝑣 (𝑢, 𝑥) = 𝑢1 𝑢2 … 𝑢𝑚 is the path between 𝑢 = 𝑢1 and 𝑥 = 𝑢𝑚 ,
                                                        46


                   𝑢                         𝑢                 𝑢                               𝑢
    (𝑛 𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑢𝑖𝑖+1 ),                      𝑖
                                𝑛 𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑢𝑖+1  )) = (𝑛𝑇 (𝑇𝑢𝑖𝑖+1 ) − 𝑛𝑇 (𝑇𝑣𝑢 ),                 𝑖
                                                                                          𝑛𝑇 (𝑇𝑢𝑖+1 ) + 𝑛𝑇 (𝑇𝑣𝑢 )),
            𝑢                    𝑢                   𝑢                         𝑢
(𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑢𝑖𝑖+1 ), 𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑢𝑖+1 𝑖
                                     )) = (𝑓𝑇 (𝑇𝑢𝑖𝑖+1 ) − 𝑓𝑇 (𝑇𝑣𝑢 ), 𝑓𝑇 (𝑇𝑢𝑖+1   𝑖
                                                                                   ) + 𝑓𝑇 (𝑇𝑣𝑢 ), 0 < 𝑖 < 𝑚.
     And, if 𝑃 𝑇𝑣𝑢 (𝑣, 𝑦) = 𝑣1 𝑣2 … 𝑣𝑛 is a path between 𝑣 = 𝑣1 and 𝑦 = 𝑣𝑛 ,
                   𝑣                    𝑣                  𝑣                           𝑣
     (𝑛𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑣𝑖𝑖+1 ), 𝑛𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑣𝑖+1   𝑖
                                             )) = (𝑛𝑇 (𝑇𝑣𝑖𝑖+1 ) − 𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑖+1  𝑖
                                                                                           ) + 𝑛𝑇 (𝑇𝑢𝑣 )),
            𝑣                     𝑣                  𝑣                         𝑣
(𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑣𝑖𝑖+1 ), 𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑣𝑖+1 𝑖
                                     )) = (𝑓𝑇 (𝑇𝑣𝑖𝑖+1 ) − 𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑖+1  𝑖
                                                                                   ) + 𝑓𝑇 (𝑇𝑢𝑣 )), 0 < 𝑖 < 𝑛.
     Proof: Assume we have the lemma assumptions. By Eq. 4.3,
          𝑊𝛼,𝛽 (𝑇𝑠𝑡\𝑢𝑣 ) = 𝑝(𝑠) + 𝑞(𝑡) + 𝑟,               𝑠 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑡 ∈ 𝑉(𝑇𝑣𝑢 ).                              (4.4)
     where 𝑟 is independent of the choice of s and 𝑡. And the values of 𝑝(𝑠) and 𝑞(𝑡) are
independent of each other. By definition, if 𝑎 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑏 ∈ 𝑉(𝑇𝑣𝑢 ) minimize Eq. 4.4
and 𝑎𝑏 ≠ 𝑢𝑣, then 𝑎𝑏 is a BS of 𝑢𝑣. One sees that by minimizing Eq. 4.4 inclusively, we
do not exclude 𝑢𝑣 as a choice for 𝑎𝑏, since:
                       𝑚𝑖𝑛 𝑝(𝑠) + 𝑚𝑖𝑛𝑢 𝑞(𝑡) + 𝑟 =                    𝑚𝑖𝑛        𝑊𝛼,𝛽 (𝑇𝑠𝑡\𝑢𝑣 ).                    (4.5)
                     𝑠∈𝑉(𝑇𝑢𝑣 )         𝑡∈𝑉(𝑇𝑣 )                 𝑠𝑡∈𝐸(𝑇 𝑐 )∪{𝑢𝑣}
     Accordingly,           (𝑎, 𝑏)minimizes           Eq.    4.4     if      and     only      if     (𝑝(𝑎), 𝑞(𝑏)) =
( 𝑚𝑖𝑛𝑣 𝑝(𝑠), 𝑚𝑖𝑛𝑢 𝑞(𝑡)). That is, (𝑎, 𝑏) = (𝑝-Root of 𝑇𝑢𝑣 , 𝑞-Root of 𝑇𝑣𝑢 ).
 𝑠∈𝑉(𝑇𝑢 )         𝑡∈𝑉(𝑇𝑣 )
     If case A happens ``which is (𝑢, 𝑣) = (𝑝-Root of 𝑇𝑢𝑣 , 𝑞-Root of 𝑇𝑣𝑢 ) and also (𝑥, 𝑦) =
(𝑝-Root of 𝑇𝑢𝑣 , 𝑞-Root of 𝑇𝑣𝑢 ), then we might have 𝑥𝑦 = 𝑢𝑣. To exclude 𝑢𝑣 in the
minimization of Eq. 4.4, we avoid the case that 𝑢 and 𝑣 appear concurrently by letting
(𝑝(𝑥), 𝑞(𝑦)) is equal to either (               𝑚𝑖𝑛     𝑝(𝑠), 𝑚𝑖𝑛𝑢 𝑞(𝑡)) or ( 𝑚𝑖𝑛𝑣 𝑝(𝑠),                 𝑚𝑖𝑛       𝑞(𝑡)).
                                            𝑠∈𝑉(𝑇𝑢𝑣 )\𝑢       𝑡∈𝑉(𝑇𝑣 )               𝑠∈𝑉(𝑇𝑢 )         𝑡∈𝑉(𝑇𝑣𝑢 ) \𝑣
By theorem 2.9 and the assumptions 𝑇𝑢𝑣 and 𝑇𝑣𝑢 are convex. That is,
            𝑚𝑖𝑛       𝑝(𝑠) =       𝑚𝑖𝑛 𝑝(𝑠) and            𝑚𝑖𝑛      𝑞(𝑡) =       𝑚𝑖𝑛 𝑞(𝑡).
         𝑠∈𝑉(𝑇𝑢𝑣 )\𝑢            𝑠∈𝑁𝑇𝑣 (𝑢)               𝑡∈𝑉(𝑇𝑣𝑢 )\𝑣           𝑡∈𝑁𝑇𝑢 (𝑣)
                                     𝑢                                             𝑣
                                                             47


        As a result, either
        1-(𝑥, 𝑦) = (𝑢, 𝑧) where 𝑞(𝑧) =             𝑚𝑖𝑛 𝑞(𝑏), or
                                                 𝑏∈𝑁𝑇𝑣 (𝑢)
                                                      𝑢
        2-(𝑥, 𝑦) = (𝑧, 𝑣) where 𝑝(𝑧) =             𝑚𝑖𝑛 𝑝(𝑎).
                                                 𝑎∈𝑁𝑇𝑣 (𝑢)
                                                      𝑢
                                                   ′                        𝑢=𝑥                  𝑦                𝑦
        By lemma 4.4, in case 1-,𝑊𝛼,𝛽                 (𝑇𝑥𝑦\𝑢𝑣 ) − 𝑟 = ∫𝑢           𝑝′𝑑𝑇𝑢𝑣 + ∫𝑣 𝑞′𝑑 𝑇𝑣𝑢 = ∫𝑣 𝑞′𝑑𝑇𝑣𝑢 =
                                            ′
     ⃗⃗⃗⃗ )𝑤𝑇 (𝑣𝑧) and in case 2- 𝑊𝛼,𝛽
𝑞 ′ (𝑣𝑧                                         (𝑇𝑥𝑦\𝑢𝑣 ) − 𝑟 = 𝑝′ (𝑢𝑧⃗⃗⃗⃗ )𝑤𝑇 (𝑢𝑧). Thus, if 𝑝′ (𝑢𝑧        ⃗⃗⃗⃗ )𝑤𝑇 (𝑢𝑧) >
     ⃗⃗⃗⃗ )𝑤𝑇 (𝑣𝑧), then 1 gives the choice of (𝑥, 𝑦). If 𝑝′ (𝑢𝑧
𝑞 ′ (𝑣𝑧                                                                     ⃗⃗⃗⃗ )𝑤𝑇 (𝑢𝑧) < 𝑞 ′ (𝑣𝑧   ⃗⃗⃗⃗ )𝑤𝑇 (𝑣𝑧), then
(𝑥, 𝑦) comes from 2. Otherwise, either 1 or 2 is the choice.
        Now assume (𝑢, 𝑣) ≠ (𝑝-Root of 𝑇𝑢𝑣 , 𝑞-Root of 𝑇𝑣𝑢 ). If (𝑎, 𝑏) = (𝑝-Root of 𝑇𝑢𝑣 , 𝑞-Root
of 𝑇𝑣𝑢 ), then (𝑢, 𝑣) ≠ (𝑎, 𝑏). Moreover, (𝑎, 𝑏) minimizes 𝑊𝛼,𝛽 in Eq. 4.4. So (𝑥, 𝑦) = (𝑎, 𝑏)
is a right choice. This completes the proof of B.
        To form 𝑇𝑥𝑦\𝑢𝑣 we remove 𝑢𝑣 ∈ 𝐸(𝑇) and re-connect the components of 𝑇 − 𝑢 using
𝑥 ∈ 𝑉(𝑇𝑢𝑣 ) and 𝑦 ∈ 𝑉(𝑇𝑣𝑢 ), 𝑢𝑣 ≠ 𝑥𝑦. Thus, 𝐹𝑇 ≠ 𝐹𝑇 𝑥𝑦\𝑢𝑣 and 𝑁𝑇 ≠ 𝑁𝑇 𝑥𝑦\𝑢𝑣 in general.
Precisely,            (𝑛𝑇 (𝑇𝑎𝑏 ), 𝑛𝑇 (𝑇𝑏𝑎 )) ≠ (𝑛𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑎𝑏 ), 𝑛 𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑏𝑎 ))               or (𝑓𝑇 (𝑇𝑎𝑏 ), 𝑓𝑇 (𝑇𝑏𝑎 )) ≠
(𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑎𝑏 ), 𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑏𝑎 )) happens if 𝑎𝑏 ∈ 𝑃𝑇 (𝑢, 𝑥) or 𝑎𝑏 ∈ 𝑃𝑇 (𝑣, 𝑦). By definition 2.1
𝑓𝑇 (𝑇𝑎𝑏 ) + 𝑓𝑇 (𝑇𝑏𝑎 ) = 𝑓𝑇 (𝑇) and 𝑛𝑇 (𝑇𝑎𝑏 ) + 𝑛𝑇 (𝑇𝑏𝑎 ) = |𝑉(𝑇)|. And, by lemma 4.3 equations
4.1 and 4.2, if 𝑃 𝑇𝑢𝑣 (𝑢, 𝑥) = 𝑢1 𝑢2 … 𝑢𝑚 is the path between 𝑢 = 𝑢1 and 𝑥 = 𝑢𝑚 ,
                   𝑢                        𝑢                 𝑢                                    𝑢
       (𝑛 𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑢𝑖𝑖+1 ),                   𝑖
                                𝑛 𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑢𝑖+1  )) = (𝑛𝑇 (𝑇𝑢𝑖𝑖+1 ) − 𝑛𝑇 (𝑇𝑣𝑢 ),                    𝑖
                                                                                             𝑛𝑇 (𝑇𝑢𝑖+1  ) + 𝑛𝑇 (𝑇𝑣𝑢 )),
               𝑢                  𝑢                 𝑢                           𝑢
(𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑢𝑖𝑖+1 ), 𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑢𝑖+1 𝑖
                                       )) = (𝑓𝑇 (𝑇𝑢𝑖𝑖+1 ) − 𝑓𝑇 (𝑇𝑣𝑢 ), 𝑓𝑇 (𝑇𝑢𝑖+1 𝑖
                                                                                      ) + 𝑓𝑇 (𝑇𝑣𝑢 )), 0 < 𝑖 < 𝑚.
        And symmetrically, for 𝑃𝑇𝑣𝑢 (𝑣, 𝑦) = 𝑣1 𝑣2 … 𝑣𝑛 with 𝑣 = 𝑣1 and 𝑦 = 𝑣𝑛 ,
                    𝑣                    𝑣                 𝑣                              𝑣
        (𝑛𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑣𝑖𝑖+1 ), 𝑛 𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑣𝑖+1
                                          𝑖
                                            )) = (𝑛𝑇 (𝑇𝑣𝑖𝑖+1 ) − 𝑛𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑣𝑖+1      𝑖
                                                                                              ) + 𝑛𝑇 (𝑇𝑢𝑣 )),
                 𝑣                   𝑣                𝑣                           𝑣
    (𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑣𝑖𝑖+1 ), 𝑓𝑇𝑥𝑦\𝑢𝑣 (𝑇𝑣𝑖+1𝑖
                                         )) = (𝑓𝑇 (𝑇𝑣𝑖𝑖+1 ) − 𝑓𝑇 (𝑇𝑢𝑣 ), 𝑓𝑇 (𝑇𝑣𝑖+1  𝑖
                                                                                        ) + 𝑓𝑇 (𝑇𝑢𝑣 )), 0 < 𝑖 < 𝑛. ■
        Lemma 4.6: For a (𝑓𝑇 , 𝑤𝑇 )-weighted tree 𝑇,
                                   𝑊× (𝑇) =       ∑ [𝑓𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 )]𝑤𝑇 (𝑢𝑣),
                                                𝑢𝑣∈𝐸(𝑇)
                                                             48


     and,
                  𝑊+ (𝑇) =        ∑ [𝑛𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ) + 𝑛𝑇 (𝑇𝑣𝑢 )𝑓𝑇 (𝑇𝑢𝑣 )]𝑤𝑇 (𝑢𝑣).
                                𝑢𝑣∈𝐸(𝑇)
     Proof: We prove the first equation using the double-counting principle. Assume 𝑇′ is
a copy of 𝑇 with the edge weights set to 0 at the start. Let 𝑢, 𝑣 ∈ 𝑉(𝑇) and 𝑃𝑇 (𝑢, 𝑣) is the
path between 𝑢 and 𝑣. For every 𝑎𝑏 ∈ 𝑃𝑇 (𝑢, 𝑣) add the number 𝑤(𝑢𝑣)𝑓𝑇 (𝑎)𝑓𝑇 (𝑏) to the
corresponding edge of 𝑎𝑏 in 𝑇′. Then ∑𝑢𝑣∈𝑃𝑇 (𝑢,𝑣) 𝑤 𝑇 ′ (𝑢𝑣) = [𝑓𝑇 (𝑢) 𝑓𝑇 (𝑣)]𝑑 𝑇 (𝑢, 𝑣). Thus,
suppose we repeat the above process for every pair 𝑢, 𝑣 ∈ 𝑉(𝑇). If so, then
                ∑       𝑤 𝑇 ′ (𝑢𝑣) = ∑            [𝑓𝑇 (𝑢) × 𝑓𝑇 (𝑣)]𝑑 𝑇 (𝑢, 𝑣) = 𝑊× (𝑇).
                                        {𝑢,𝑣}⊆𝑉(𝑇)
             𝑢𝑣∈𝐸(𝑇 ′ )
     And on the other hand, one can see that 𝑤 𝑇 ′ (𝑢𝑣) = 𝑤𝑇 (𝑢𝑣) 𝑇 [𝑓𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 )] for 𝑢𝑣 ∈
𝐸(𝑇′). Thus, 𝑊× (𝑇) = ∑𝑢𝑣∈𝐸(𝑇 ′ ) 𝑤 𝑇 ′ (𝑢𝑣) = ∑𝑢𝑣∈𝐸(𝑇) 𝑤𝑇 (𝑢𝑣)[𝑓𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 )]. This proves the
formula of 𝑊× (𝑇). The proof for the 𝑊+ case is quite similar.                                     ■
     Corollary 4.7: Assume 𝑇 is a (𝑓𝑇 , 𝑤𝑇 )-weighted 𝑛-vertex tree. We can compute
𝑊× (𝑇) and 𝑊+ (𝑇) in 𝑂(𝑛)-time. Moreover, if by changing the weight of 𝑎𝑏 ∈ 𝐸(𝑇) to 𝑤,
we get a tree 𝑇′, then
                         𝑊× (𝑇′) = 𝑊× (𝑇) + (𝑤−𝑤𝑇 (𝑎𝑏))𝑓𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ),
            𝑊× (𝑇′) = 𝑊× (𝑇) + (𝑤−𝑤𝑇 (𝑎𝑏))[𝑛𝑇 (𝑇𝑢𝑣 )𝑓𝑇 (𝑇𝑣𝑢 ) + 𝑛𝑇 (𝑇𝑣𝑢 )𝑓𝑇 (𝑇𝑢𝑣 )].               ■
     Remark 4.8: Here, we give a simple intuition behind an algorithm for problem 1
when the tree 𝑇 is positively weighted. Using lemma 4.5, finding a BS for 𝑢𝑣 ∈ 𝐸(𝑇), we
need to have the 𝑝-Roots and 𝑞-Roots of 𝑇𝑢𝑣 and 𝑇𝑣𝑢 , respectively. By definition 𝑢 ∈ 𝑉(𝑇𝑢𝑣 )
and 𝑣 ∈ 𝑉(𝑇𝑣𝑢 ). By corollary 2.10, the longest decreasing path from 𝑢 ends up with a 𝑝-
Root of 𝑇𝑢𝑣 say 𝑥, and similarly, the longest decreasing path from 𝑣 ends up to a 𝑞-Root
of 𝑇𝑣𝑢 say 𝑦. Moreover, by corollary 2.10, those paths are the only decreasing paths in
                                                    49


their respective components. So, one can easily take some derivatives to reach from 𝑢 to
𝑥 or from 𝑣 to 𝑦 since the paths are decreasing and unique. Then by lemma 4.5, a BS of
𝑢𝑣 is one of the following cases as detailed in the lemma.
      1. 𝑥𝑦,
      2. an edge between 𝑥 and a vertex of 𝑁𝑇 (𝑦),
      3. an edge between 𝑦 and a vertex of 𝑁𝑇 (𝑥).
      Lemma 4.5 details how to choose among the above limited cases using derivatives. As
we find the unique and decreasing path between 𝑢 and 𝑥 and also 𝑣 and 𝑦, one can update
𝑄𝑇 as in lemma 4.5. Having those paths also eases calculating 𝑊× , 𝑊+ , and 𝑊𝛼,𝛽 from
lemma 4.4. The following proposition details the mentioned intuition with proof of time
complexity.                                                                                         ▲
      Proposition 4.9: Let 𝑇 be an 𝑛-vertex positively weighted tree with a Coordinate𝑄𝑇 .
If we get 𝑒 ∈ 𝐸(𝑇) and 𝑤, 𝛼, 𝛽 ∈ ℝ≥0, then we can compute, 𝜖, 𝑇𝜖\𝑒 , 𝑄𝑇𝜖\𝑒 , and 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ),
with the worst average time of 𝑂(log 𝑛) and the best average time of 𝑂(1), where 𝜖 is a
BS of 𝑒 w.r.t 𝑊𝛼,𝛽 and 𝑤𝑇𝜖\𝑒 (𝜖) = 𝑤. Updating, 𝑄𝑇 after edge weight change is supported
in 𝑂(1)-time per change.
      Proof:      Assume we have an              𝑛-vertex    positively      weighted   tree  𝑇,  𝑄𝑇 =
{𝐹𝑇 , 𝑁𝑇 , 𝑊× (𝑇), 𝑊+ (𝑇)} and 𝑢𝑣 ∈ 𝐸(𝐺), 𝑛 > 2. Let 𝑝 and 𝑞 be some induced vertex weight
functions for 𝑇𝑢𝑣 an 𝑇𝑣𝑢 as follows,
            𝑝𝛼,𝛽 (𝑐) = [𝛼𝑓𝑇 (𝑇𝑣𝑢 ) + 𝛽𝑛𝑇 (𝑇𝑣𝑢 )]ℎ𝑇𝑢𝑣 (𝑐) + 𝛽𝑓𝑇 (𝑇𝑣𝑢 )𝜎 𝑇𝑢𝑣 (𝑐),      𝑐 ∈ 𝑉(𝑇𝑢𝑣 ),
            𝑞𝛼,𝛽 (𝑐) = [𝛼𝑓𝑇 (𝑇𝑢𝑣 ) + 𝛽𝑛𝑇 (𝑇𝑢𝑣 )]ℎ𝑇𝑣𝑢 (𝑐) + 𝛽𝑓𝑇 (𝑇𝑢𝑣 )𝜎 𝑇𝑣𝑢 (𝑐),     𝑐 ∈ 𝑉(𝑇𝑣𝑢 ).
      Then with the results, we have the following:
                                                       50


     1-Computing a 𝒑′ or 𝒒′ in 𝑶(𝟏)-time. Using 𝐹𝑇 , 𝑁𝑇 , lemma 4.3, and definition
2.2, computing 𝑝′(𝑟𝑠      ⃗⃗⃗ ) costs 𝑂(1)-time for any 𝑟𝑠 ∈ 𝑃 𝑇𝑢𝑣 (𝑢, 𝑥) where 𝑥 ∈ 𝑉(𝑇𝑢𝑣 ) and we
know the direction. A similar argument holds for computing 𝑞 ′ on 𝑃 𝑇𝑣𝑢 (𝑣, 𝑦).
     2-Checking whether a vertex is a Root in 𝑶(𝟏)-time on average. By corollary
2.10, if 𝑝′(𝑢𝑥
             ⃗⃗⃗⃗ ) < 0 for only one 𝑥 ∈ 𝑁𝑇𝑢𝑣 (𝑢), then 𝑢 is not a 𝑝-Root. The following can
verify whether a vertex is 𝑝 or 𝑞-Root or not. (Let 𝑓 = 𝑝 or 𝑞)
# Takes a vertex and a 𝑓 and says it is a 𝑓-Root or not
𝑰𝑺_𝑹𝒐𝒐𝒕(𝑎 , 𝑓)
𝑭𝒐𝒓 𝑠 ∈ 𝑁(𝑎)
          𝒊𝒇 𝑓 ′ (𝑎𝑠
                  ⃗⃗⃗⃗ ) < 0
               𝒓𝒆𝒕𝒖𝒓𝒏 𝐹𝑎𝑙𝑠𝑒
𝒓𝒆𝒕𝒖𝒓𝒏 𝑇𝑟𝑢𝑒
     The average degree in a tree is 𝑂(1). Thus, 𝑰𝑺_𝑹𝒐𝒐𝒕 run time is 𝑂(1) on average.
     3-Finding a neighbor with a minimum 𝒑 or 𝒒 in 𝑶(𝟏)-time on average. If
𝑠 ∈ 𝑁 𝑇𝑢𝑣 (𝑎), then by definition 2.2, 𝑝(𝑠) = 𝑝′(𝑎𝑠 ⃗⃗⃗⃗ )𝑤(𝑎𝑠) + 𝑝(𝑎). By 1- computing 𝑝(𝑠) takes
𝑂(1)-time. Moreover, 𝑂(|𝑁𝑇 (𝑎)|) = 𝑂(1) on average. Thus, finding 𝑥 with 𝑝(𝑥) =
  𝑚𝑖𝑛 𝑝(𝑠) takes 𝑂(1)-time on average. Computing min 𝑞 neighbor follows the same
𝑠∈𝑁𝑇𝑣 (𝑎)
    𝑢
rules. One implements the mentioned idea as follows.
                                                     51


#Takes a vertex, 𝑎, finds 𝑥 ∈ 𝑁(𝑎) with min 𝑓 and returns 𝑥 and 𝑎𝑥 (𝑓 = 𝑝 or 𝑞)
𝑭𝑵𝑫_𝒎𝒊𝒏( 𝑎, 𝑓)
𝑚𝑖𝑛 = ∞
𝑭𝒐𝒓 𝑠 ∈ 𝑁(𝑎)
                𝑓(𝑠) = 𝑓′(𝑎𝑠  ⃗⃗⃗⃗ )𝑤(𝑎𝑠) + 𝑓(𝑎)
              𝒊𝒇 𝑓(𝑠) < 𝑚𝑖𝑛
                                 𝑚𝑖𝑛 = 𝑓(𝑠)
                                 𝑥←𝑠
𝒓𝒆𝒕𝒖𝒓𝒏 𝑥 , 𝑎𝑥
    4-Finding, 𝑷𝑻𝒗𝒖 (𝒖, 𝒙) or 𝑷𝑻𝒖𝒗 (𝒗, 𝒚) in 𝑶(𝐥𝐨𝐠 𝒏) on average, where 𝒙 and 𝒚 are 𝒑
or𝒒-Root. By theorem 2.9, 𝑇𝑢𝑣 is 𝑝-convex. Assume that 𝑃 = 𝑢1 𝑢2 … 𝑢𝑚 is the decreasing
path between 𝑢 = 𝑢1 and a 𝑝-Root, 𝑢𝑚 . By corollary 2.10, 𝑃 is the longest decreasing path
beginning with 𝑢, and 𝑝′(𝑢             𝑖 𝑎 ) < 0 if and only if 𝑎 = 𝑢𝑖+1 , 𝑎 ∈ 𝑁(𝑣𝑖 ), 0 < 𝑖 < 𝑚. So,
                                    ⃗⃗⃗⃗⃗⃗
starting with 𝑖 = 1, we can find 𝑢𝑖+1 when we have 𝑢𝑖 and compute 𝑃 as follows.
# Takes a vertex, 𝑎, and returns 𝑐 and 𝑃(𝑎, 𝑐) where 𝑐 is a 𝑓-Root (𝑓 = 𝑝 or 𝑞)
𝑹𝒐𝒐𝒕_𝑷𝒂𝒕𝒉(𝑎, 𝑓)
𝑃(𝑎, 𝑐) = 𝑎1 = 𝑎
    𝑳𝒂𝒃𝒍𝒆
    𝑭𝒐𝒓 𝑎𝑖+1 ∈ 𝑁(𝑎𝑖 )\𝑎𝑖−1
        𝒊𝒇 𝑓 ′ (𝑎  𝑖 𝑎𝑖+1 ) < 0.
                ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
                𝑃(𝑎, 𝑐) = 𝑃(𝑎, 𝑐) ∪ 𝑎𝑖+1
                𝑎𝑖 ← 𝑎𝑖+1
                𝑩𝒓𝒆𝒂𝒌 𝒂𝒏𝒅 𝑮𝒐𝒕𝒐 𝑳𝒂𝒃𝒍𝒆
     𝒓𝒆𝒕𝒖𝒓𝒏 𝑎, 𝑃(𝑎, 𝑐)
                                                        52


      For finding 𝑢𝑖+1 from 𝑢𝑖 , we can exclude 𝑢𝑖−1 and jump to 𝑢𝑖+1 as the process
𝑹𝒐𝒐𝒕_𝑷𝒂𝒕𝒉 does. That reduces the average complexity. Moreover, when we are on the
vertex 𝑢𝑖 , 𝑖 < 𝑚, one takes at most |𝑁(𝑢𝑖 )| derivatives to find 𝑢𝑖+1, since we know, 𝑢𝑖+1
is the only vertex with negative derivatives toward it. So, 𝑹𝒐𝒐𝒕_𝑷𝒂𝒕𝒉(𝑢, 𝑝) returns,
𝑃𝑇𝑢𝑣 (𝑢, 𝑥) by taking some derivatives, at most, as many as the total degree of the vertices
on 𝑃 𝑇𝑢𝑣 (𝑢, 𝑥), where 𝑥 is a 𝑝-Root. By [20], the path length in a tree is 𝑂(log 𝑛) on average,
where it can be 𝑂(1) as well. In addition, the average degree in a tree is 𝑂(1), and taking
each derivative requires 𝑂(1)-time. Moreover, 𝑥 is a 𝑝-Root (has min 𝑝) and 𝑇𝑢𝑣 < 𝑇.
Thus, the worst average run time of 𝑹𝒐𝒐𝒕_𝑷𝒂𝒕𝒉(𝑢, 𝑝) is 𝑂(log 𝑛) and the best average
time is 𝑂(1). Similarly, 𝑹𝒐𝒐𝒕_𝑷𝒂𝒕𝒉(𝑣, 𝑞) has the same run time to return 𝑃 𝑇𝑣𝑢 (𝑣, 𝑦) where
𝑦 is a 𝑞-Root.
                           𝒙                  𝒚
      5-Computing ∫𝒖 𝒑′𝒅𝑻𝒗𝒖 and ∫𝒗 𝒒′𝒅𝑻𝒖𝒗 in 𝑶(|𝑷(𝒖, 𝒙)|)-time and 𝑶(|𝑷(𝒗, 𝒚)|)-time,
respectively. By definition 2.12, theorem 2.13, and 1-, if we have a path, 𝑃 = 𝑎1 𝑎2 … 𝑎𝑚 ,
we can compute the integral of 𝑃 in 𝑂(𝑚)-time as follows.
# Takes a path 𝑃 and 𝑓 and returns ∫𝑃 𝑓′ (𝑓 = 𝑝 or 𝑞)
       𝑰𝒏𝒕𝒆𝒈 (𝑃 = 𝑎1 𝑎2 … 𝑎𝑚 , 𝑓)
       𝑎
      ∫𝑎1 𝑓 ′ 𝑑 = 0
         𝑚
      𝑭𝒐𝒓 0 < 𝑖 < 𝑚
                  𝑎
                 ∫𝑎1 𝑓 ′ 𝑑 += 𝑓′(𝑎
                    𝑚
                                    𝑖 𝑎𝑖+1 ). 𝑤(𝑎𝑖 𝑎𝑖+1 )
                                 ⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗⃗
                   𝑎
      𝒓𝒆𝒕𝒖𝒓𝒏 ∫𝑎 𝑚 𝑓 ′ 𝑑
                    1
      6-Updating 𝑭𝑻 to 𝑭𝑻𝒙𝒚\𝒖𝒗 and 𝑵𝑻 to 𝑵𝑻𝒙𝒚\𝒖𝒗 in 𝑶(|𝑷(𝒖, 𝒙)|)+𝑶(|𝑷(𝒗, 𝒚)|) time.
By lemma 4.5, 𝑼𝒑_𝑭𝑵(𝑃(𝑢, 𝑥), 𝑓𝑇 (𝑇𝑣𝑢 ), 𝑛𝑢𝑇 (𝑣)) and 𝑼𝒑_𝑭𝑵(𝑃(𝑣, 𝑦), 𝑓𝑇 (𝑇𝑢𝑣 ), 𝑛𝑣𝑇 (𝑢)) updates
𝑭𝑻 to 𝑭𝑻𝒙𝒚\𝒖𝒗 and 𝑵𝑻 to 𝑵𝑻𝒙𝒚\𝒖𝒗 , where 𝑼𝒑_𝑭𝑵 is a process as follows.
                                                       53


# Takes a path and updates 𝐹𝑇 and 𝑁𝑇 accordingly
𝑼𝒑_𝑭𝑵(𝑃 = 𝑣1 𝑣2 … 𝑣𝑚 , 𝐹, 𝑁)
     𝑭𝒐𝒓 0 < 𝑖 < 𝑚
                 𝑣             𝑣                 𝑣                  𝑣
         (𝑛𝑇 (𝑇𝑣𝑖𝑖+1 ), 𝑛𝑇 (𝑇𝑣𝑖+1𝑖
                                    )) ← (𝑛𝑇 (𝑇𝑣𝑖𝑖+1 ) − 𝑁, 𝑛𝑇 (𝑇𝑣𝑖+1𝑖
                                                                        ) + 𝑁)
                𝑣            𝑣                𝑣                 𝑣
         (𝑓𝑇 (𝑇𝑣𝑖𝑖+1 ), 𝑓𝑇 (𝑇𝑣𝑖+1
                               𝑖
                                   )) ← (𝑓𝑇 (𝑇𝑣𝑖𝑖+1 ) − 𝐹, 𝑓𝑇 (𝑇𝑣𝑖+1
                                                                  𝑖
                                                                      ) + 𝐹)
     Using the devised procedures in 1- to 6-, we can implement lemma 4.4 and 4.5, which
finds us 𝜖, 𝑇𝜖\𝑒 , 𝑄𝑇𝜖\𝑒 , and 𝑊𝛼,𝛽 (𝑇𝜖\𝑒 ), for the input 𝑒 ∈ 𝐸(𝑇) and 𝑤, 𝛼, 𝛽 ∈ ℝ≥0 , where 𝜖
is a BS of 𝑒 w.r.t 𝑊𝛼,𝛽 and 𝑤𝑇𝜖\𝑒 (𝜖) = 𝑤. The full detail is presented with the following
algorithm: BS algorithm. Each line's average time complexity bound is shown from the
results
     BS Algorithm
     Input:
     1. Adj list of a (𝑓𝑇 , 𝑤𝑇 )-weighted tree 𝑇,
     2. 𝑢𝑣 ∈ 𝐸(𝑇),
     3. 𝑄𝑇 ,
     4. 𝑤, 𝛼, 𝛽 ∈ ℝ+
     Output:
     1. 𝑥𝑦, where 𝑥𝑦 is a BS of 𝑢𝑣 w.r.t. 𝑊𝛼,𝛽 and 𝑤𝑇 (𝑥𝑦) = 𝑤
     2. 𝑇𝑥𝑦\𝑢𝑣 ,
     3. 𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ),
     4. 𝑄𝑇𝑥𝑦\𝑢𝑣 ,
        Preprocessing---------------------------------------------------------------------------------------
        Compute 𝑄𝑇 = {𝐹𝑇 , 𝑁𝑇 , 𝑊× (𝑇), 𝑊+ (𝑇)}               #𝑂(𝑛)        corollary 2.6 & lemma 4.6
                                                        54


     ----------Finding 𝑥, 𝑦, 𝑃(𝑢, 𝑥) and 𝑃(𝑣, 𝑦) where 𝑥𝑦 is a BS of 𝑢𝑣; (lemma 4.5 )---------
     𝒊𝒇 𝑰𝑺_𝑹𝒐𝒐𝒕(𝑢, 𝑝) 𝑎𝑛𝑑 𝑰𝑺_𝑹𝒐𝒐𝒕(𝑣, 𝑞)                                #𝑂(1)
        {
           𝑎 , 𝑢𝑎 ← 𝑭𝑵𝑫_𝒎𝒊𝒏(𝑢, 𝑝)                                  #𝑂(1)
           𝑏 , 𝑣𝑏 ← 𝑭𝑵𝑫_𝒎𝒊𝒏(𝑣, 𝑞)                                  #𝑂(1)
                           ⃗⃗⃗⃗ )𝑤𝑇 (𝑣𝑏) < 𝑝′ (𝑢𝑎
                   𝒊𝒇 𝑞 ′ (𝑣𝑏                   ⃗⃗⃗⃗ )𝑤𝑇 (𝑢𝑎)           #𝑂(1)
                                  {𝑥, 𝑃(𝑢, 𝑥) ← 𝑢, 𝑢
                                     𝑦, 𝑃(𝑣, 𝑦) ← 𝑏, 𝑣𝑏}
              𝒆𝒍𝒔𝒆
                                  {𝑥, 𝑃(𝑢, 𝑥) ← 𝑎, 𝑢𝑎
                                     𝑦, 𝑃(𝑣, 𝑦) ← 𝑣, 𝑣}
        }
        𝒆𝒍𝒔𝒆
     {𝑥, 𝑃(𝑢, 𝑥) ← 𝑹𝒐𝒐𝒕_𝑷𝒂𝒕𝒉(𝑢, 𝑝)                     # 𝑂(log 𝑛) on ave
       𝑦, 𝑃(𝑣, 𝑦) ← 𝑹𝒐𝒐𝒕_𝑷𝒂𝒕𝒉(𝑣, 𝑞)}                   # 𝑂(log 𝑛) on ave
     ----------------Computing 𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 )-------( lemma 4.4 )--------------------------------
  ′
𝑊𝛼,𝛽  (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑰𝒏𝒕𝒆𝒈(𝑃(𝑢, 𝑥), 𝑝𝛼,𝛽 ) + 𝑰𝒏𝒕𝒆𝒈(𝑃(𝑣, 𝑦), 𝑞𝛼,𝛽 ) + 𝐹𝑁𝛼,𝛽 (𝑢𝑣)[𝑤 − 𝑤𝑇 (𝑢𝑣)]
#𝑂(|𝑃𝑇𝑢𝑣 (𝑢, 𝑥)|) + 𝑂(|𝑃 𝑇𝑣𝑢 (𝑣, 𝑦)|)
     𝑊𝛼,𝛽 (𝑇) = 𝛼𝑊× (𝑇) + 𝛽𝑊+ (𝑇)                                                            #𝑂(1)
                              ′
     𝑊𝛼,𝛽 (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑊𝛼,𝛽       (𝑇𝑥𝑦\𝑢𝑣 )+𝑊𝛼,𝛽 (𝑇)                                          #𝑂(1)
     -------- 𝑄𝑇 ← 𝑄𝑇𝑥𝑦\𝑢𝑣 ---------updating 𝑄𝑇 --------( lemma 4.5 )----------------------------------
     𝑼𝒑_𝑭𝑵(𝑃(𝑢, 𝑥), 𝑓𝑇 (𝑇𝑣𝑢 ), 𝑛𝑇 (𝑇𝑣𝑢 )) ∧ 𝑼𝒑_𝑭𝑵(𝑃(𝑣, 𝑦), 𝑓𝑇 (𝑇𝑢𝑣 ), 𝑛𝑇 (𝑇𝑢𝑣 ))
                                                                         # 𝑂(|𝑃𝑇𝑢𝑣 (𝑢, 𝑥)| + |𝑃 𝑇𝑣𝑢 (𝑣, 𝑦)|)
  ′
𝑊1,0 (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑊×′ (𝑇𝑥𝑦\𝑢𝑣 )
                  = 𝑰𝒏𝒕𝒆𝒈(𝑃(𝑢, 𝑥), 𝑝1,0 ) + 𝑰𝒏𝒕𝒆𝒈(𝑃(𝑣, 𝑦), 𝑞1,0 ) + 𝐹𝑁1,0 (𝑢𝑣)[𝑤 − 𝑤𝑇 (𝑢𝑣)]
                                                                         # 𝑂(|𝑃𝑇𝑢𝑣 (𝑢, 𝑥)| + |𝑃 𝑇𝑣𝑢 (𝑣, 𝑦)|)
                                                          55


   ′
𝑊0,1 (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑊+′ (𝑇𝑥𝑦\𝑢𝑣 )
                = 𝑰𝒏𝒕𝒆𝒈(𝑃(𝑢, 𝑥), 𝑝0,1 ) + 𝑰𝒏𝒕𝒆𝒈(𝑃(𝑣, 𝑦), 𝑞0,1 ) + 𝐹𝑁0,1 (𝑢𝑣)[𝑤 − 𝑤𝑇 (𝑢𝑣)]
                                                                          # 𝑂(|𝑃𝑇𝑢𝑣 (𝑢, 𝑥)| + |𝑃 𝑇𝑣𝑢 (𝑣, 𝑦)|)
𝑊× (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑊×′ (𝑇𝑥𝑦\𝑢𝑣 )−𝑊× (𝑇)                             #𝑂(1)
𝑊+ (𝑇𝑥𝑦\𝑢𝑣 ) = 𝑊+′ (𝑇𝑥𝑦\𝑢𝑣 )−𝑊+ (𝑇)                             #𝑂(1)
     ---------𝑇 ← 𝑇𝑥𝑦\𝑢𝑣 ---------------
     𝑇 ← 𝑇 + 𝑥𝑦 − 𝑢𝑣                                                  #𝑂(1)
     Using 1- to 6-, the average time complexity of every line of the BS algorithm is
bounded by, max{ 𝑂(|𝑃 𝑇𝑢𝑣 (𝑢, 𝑥)|, 𝑂(|𝑃 𝑇𝑣𝑢 (𝑣, 𝑦)|}. By [20], the average path length of 𝑇 is
𝑂(log 𝑛) which accounts for the worst average time complexity of the algorithm. The best
average complexity can be 𝑂(1), because max{ 𝑂(|𝑃 𝑇𝑢𝑣 (𝑢, 𝑥)|, 𝑂(|𝑃 𝑇𝑣𝑢 (𝑣, 𝑦)|} and the
degrees on 𝑃𝑇𝑢𝑣 (𝑢, 𝑥) and 𝑃 𝑇𝑣𝑢 (𝑣, 𝑦) can be 𝑂(1). Finally, assume 𝑇′ is a tree and we have
the preprocessing, 𝑄 𝑇 ′ = {𝐹𝑇 ′ , 𝑁 𝑇 ′ , 𝑊× (𝑇 ′ ), 𝑊+ (𝑇 ′ )}. If we change the weight of one edge,
then 𝐹 𝑇 ′ and 𝑁 𝑇 ′ remain unchanged, and by corollary 4.7, we can update 𝑊× and 𝑊+ in
𝑂(1)-time. This completes the proof.                                                                       ■
     The subsequent two propositions can be proved based on proposition 4.9. They are
about solving problems 4.1 (OBS) and 4.2 (ABS), respectively.
     Proposition 4.10: Let 𝑇 be an 𝑛-vertex positively weighted tree with 𝐸(𝑇) = {𝑒𝑖 }𝑛𝑖=1 .
If we get {𝑤𝑖 , 𝛼𝑖 , 𝛽𝑖 ∈ ℝ≥0 }𝑛𝑖=1, then we can find an𝑟 such that 𝑊𝛼𝑟 ,𝛽𝑟 (𝑇𝜖𝑟 \𝑒𝑟 ) =
𝑚𝑖𝑛{𝑊𝛼𝑖 ,𝛽𝑖 (𝑇𝜖𝑖 \𝑒𝑖 )}𝑛𝑖=1 and compute 𝑊𝛼𝑟 ,𝛽𝑟 (𝑇𝜖𝑟 \𝑒𝑟 ), in an average time of 𝑂(𝑛 log 𝑛) and the
best time of 𝑂(𝑛), where 𝜖𝑖 with 𝑤𝑖 = 𝑤(𝜖𝑖 ) is a BS of 𝑒𝑖 w.r.t. 𝑊𝛼𝑖 ,𝛽𝑖 , 0 ≤ 𝑖 ≤ 𝑛.                     ■
     Proposition 4.11: Let 𝑇 be an 𝑛-vertex positively weighted tree with 𝐸(𝑇) = {𝑒𝑖 }𝑛𝑖=1 .
If we get {𝑤𝑖 , 𝛼𝑖 , 𝛽𝑖 ∈ ℝ}𝑛𝑖=1 , then we can find a BS, 𝜖𝑖 with 𝑤𝑖 = 𝑤(𝜖𝑖 ) w.r.t. 𝑊𝛼𝑖 ,𝛽𝑖 for all
𝑒𝑖 and compute 𝑊𝛼𝑖 ,𝛽𝑖 (𝑇𝜖𝑖 \𝑒𝑖 ), 0 ≤ 𝑖 ≤ 𝑛, in an average time of 𝑂(𝑛 log 𝑛) and the best
time of 𝑂(𝑛).                                                                                              ■
                                                       56


     For simplicity, we avoided adding some facts for better performance of the BS
algorithm. For example, by corollary 2.10, a leaf is not a Root of a tree with more than 2
vertices. In the BS algorithm, we either require a Root or a neighbor of a Root. Thus, if
𝑇𝑢𝑣 or 𝑇𝑢𝑣 are not trivial (single vertex), then the version of 𝑇 without the leaves can be
used. That improves the actual performance of the BS algorithm.
     Proposition 4.12: For a simple tree 𝑇, there are most 𝑊(𝑇) distinct switches. More
precisely,
     |{𝑇𝜖\𝑒 | (𝜖, 𝑒) ∈ 𝐸(𝑇 𝑐 ∪ 𝑇) × 𝐸(𝑇) ∧ 𝑇𝜖\𝑒 is a switch}| = 𝑊(𝑇),
     and if 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ∪ 𝑇) and 𝑢𝑣 ∈ 𝐸(𝑇),
                        |{𝑇𝑥𝑦\𝑒 | 𝑒 ∈ 𝐸(𝑇) ∧ 𝑇𝑥𝑦\𝑒 is a switch }| = 𝑑 𝑇 (𝑥, 𝑦),
                 |{𝑇𝜖\𝑢𝑣 | 𝜖 ∈ 𝐸(𝑇 𝑐 ∪ 𝑇) ∧ 𝑇𝜖\𝑢𝑣 is a switch }| = 𝑛𝑇 (𝑇𝑣𝑢 ). 𝑛𝑇 (𝑇𝑢𝑣 ).
     Proof: Let 𝑇 be a simple tree. Using definition 1.6, 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ∪ 𝑇) is a switch of 𝑒 ∈
𝐸(𝑇), if and only if 𝑒 ∈ 𝑃𝑇 (𝑥, 𝑦). Otherwise, 𝑇𝑥𝑦\𝑒 is disconnected, indicating that it is not
a switch. Therefore, there are exactly 𝑑 𝑇 (𝑥, 𝑦) distinct switches regarding 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ∪ 𝑇).
Thus, the total number of distinct switches is as follows:
                |{𝑇𝑥𝑦\𝑒 | (𝑥𝑦, 𝑒) ∈ 𝐸(𝑇 𝑐 ∪ 𝑇) × 𝐸(𝑇) ∧ 𝑇𝑥𝑦\𝑒 is a switch}|
                                =     ∑          𝑑 𝑇 (𝑥, 𝑦) =     ∑       𝑑 𝑇 (𝑥, 𝑦) = 𝑊(𝑇).
                                   𝑥𝑦∈𝐸(𝑇 𝑐 ∪𝑇).              {𝑥,𝑦}⊆∈𝑉(𝑇)
     And |{𝑇𝑥𝑦\𝑒 | 𝑒 ∈ 𝐸(𝑇) ∧ 𝑇𝑥𝑦\𝑒 is a switch }| = 𝑑𝑇 (𝑥, 𝑦). In addition, 𝑇𝜖\𝑢𝑣 is a tree if
and only if 𝜖 is an edge between 𝑇𝑢𝑣 and 𝑇𝑣𝑢 . Thus, |{𝑇𝜖\𝑢𝑣 | 𝜖 ∈ 𝐸(𝑇 𝑐 ∪ 𝑇) ∧
𝑇𝜖\𝑢𝑣 is a switch }| = 𝑛𝑇 (𝑇𝑣𝑢 ). 𝑛𝑇 (𝑇𝑢𝑣 ). This completes the proof.                               ■
                                                                                             𝑛2
     For 𝑢𝑣 ∈ 𝐸(𝑇) of a simple tree 𝑇 with 𝑛 vertices, 𝑛 − 1 ≤ 𝑛𝑇 (𝑇𝑣𝑢 ). 𝑛𝑇 (𝑇𝑢𝑣 ) ≤           . Also,
                                                                                             4
by [10,11,17], (𝑛 − 1)2 ≤ 𝑊(𝑇) ≤ (𝑛+1       3
                                               ).
                                                         57


     4.3 Some Comparisons and Discussion
     In this section, we compare our method with some existing methods. For brevity, we
mean average time complexity once we talk about complexity. The compared methods
are not clearly solving the same problems that we did. But it is possible to convert them
with some effort.
     The top tree method can find a positively weighted tree's median(s). It is almost
equivalent to finding the Root of a tree in our method, disregarding 𝛼 and 𝛽. Thus, for
an 𝑛-vertex tree, 𝑇 and 𝑢𝑣 ∈ 𝐸(𝑇), we somehow can convert the top tree methods [7-9] to
find a BS w.r.t. 𝑊𝛼=1,𝛽=0 in 𝑂(log 𝑛)-time for most cases. However, if 𝑢𝑣 connects a Root
of 𝑇𝑢𝑣 and a Root of 𝑇𝑣𝑢 , then the top tree method does not work. They also do not compute
𝑊𝛼,𝛽 of the switches regularly, which does not let us solve problem 2 even for their specific
case of 𝛼 = 1, 𝛽 = 0. Generalizing the top tree method, we may be able to solve problem
1 for a fixed 𝛼, 𝛽 and compute 𝑊𝛼,𝛽 , which is overcomplicated intuitively. But, if we renew
the initial values of 𝛼, 𝛽 to some 𝛼′, 𝛽′, then we have to repeat their 𝑂(𝑛)-time
preprocessing, which is costly. As we have seen, our method in BS algorithm solves
                                                           ′
problem 1 in 𝑂(log 𝑛) for any 𝛼, 𝛽 ∈ ℝ≥0, computes 𝑊𝛼,𝛽       s and does not require a fresh
preprocessing for the change of 𝛼, 𝛽. Our method updates the preprocessing, 𝑄𝑇 in 𝑂(1)-
time after an edge weight change, whereas using top trees, an edge weight update takes
up to 𝑂(log 𝑛)-time.
     For another comparison, we borrow the solution of the best swap edge of multiple-
source routing tree algorithms [15, 19-21, 29, 30] for problem 3. Suppose 𝑇 is a spanning
tree of a positively edge-weighted graph 𝐺 with 𝑚 edges and 𝑛 vertices. Then, in [15, 19-
21, 29, 30], researchers choose the BS from 𝐸(𝐺) − 𝐸(𝑇), whereas we choose from 𝐸(𝑇 𝑐 ).
Therefore, by choosing 𝐺 to be 𝐾𝑛 , the mentioned algorithms can solve problem 3. Also,
they choose the BS w.r.t. the routing cost rather than its generalization, 𝑊𝛼,𝛽 . Let 𝑆 ⊆
𝑉(𝐺) be a set of sources and |𝑆| > 1. Setting 𝑓𝐺 (𝑣) = 1 for all 𝑣 ∈ 𝑆 and 𝑓𝐺 (𝑣) = 0 for all
𝑣 ∈ 𝑉(𝐺)\𝑆, results in
                                                58


                                       𝑊1,−1 (𝐺) = 𝑅𝐶(𝐺, 𝑆).
     That is, by specifying vertices weights as mentioned and letting 𝛼𝑖 = 1, 𝛽𝑖 = −1 for
1 ≤ 𝑖 ≤ 𝑛, and 𝐺 = 𝐾𝑛 , algorithms of [20,21] will solve problem 3. The mentioned
algorithms are expensive specifically for a single failed edge, and after updating the edge
weights or inserting a BS, their 𝑂(𝑛2 ) preprocessing is not valid. They do not also compute
𝑊𝛼,𝛽 ’s. More importantly, regarding the mentioned conversion, they solve problem 3 in
more than 𝑂(𝑛2 log 𝟐 𝑛)-time and up to 𝑂(𝑛3 ) depending on the number of sources, where
𝛼𝑖 = 1, 𝛽𝑖 = −1, 1 ≤ 𝑖 ≤ 𝑛 and sources are specified. In the terminology of [20-22], we do
not limit the number of sources and, 𝛼𝑖 , 𝛽𝑖 ∈ 𝑅 ≥0 , 1 ≤ 𝑖 ≤ 𝑛 , where we attain an average
time of 𝑂(𝑛 log 𝑛) and the best time of 𝑂(𝑛) for problem 3.
     As a general fact, note that choosing a brute-force strategy and distance matrix for
the positively edge-weighted graph, computing 𝑊𝛼,𝛽 (𝑇) takes 𝑂(𝑛3 ). Moreover, there are
                    𝑛2
between 𝑛 − 1 to       switches regarding an edge. Therefore, using the bute-force strategy,
                    4
we will need between 𝑂(𝑛4 ) to 𝑂(𝑛5 ) time to compute a switch with the minimum 𝑊𝛼,𝛽 .
While our method executes that in 𝑂(log 𝑛), with the same flexibility. This difference is
significant. Note that the existing discussed methods are comparable to ours with some
constraints, but they have much less flexibility.
     Our tools is general and can be applied to similar optimization problems. For instance,
see [15], where we use our method for the best swap edge of spanning trees. Another
interesting    problem     can   be   solving   the    BS    problems   regarding    𝑘
                                                                                       𝐷(𝑇) =
                     𝑘
∑{𝑢,𝑣}⊆𝑉(𝑇)(𝑑(𝑢, 𝑣)) by considering the weight 𝑘𝜎𝑇 (𝑣) = ∑𝑥∈𝑉(𝑇) 𝑑 𝑘𝑇 (𝑣, 𝑥) for the vertices
of a tree, 𝑇. See the appendix, where we have some computations related to the derivative
and integral of, 2𝜎𝑇 .                                                                     ▲
     Finding the minimum 𝑝-sources routing cost spanning tree is an 𝑁𝑃-hard problem for
any 𝑝 > 1 and is a polynomial problem for 𝑝 = 1 [29-31].
                                                59


                                         REFERENCES
[1] Christos Alexopoulos, Jay A. Jacobson, State space partition algorithms for stochastic
     systems with applications to minimum spanning trees, Networks, 35 (2000), 118-138.
[2] Furqan Aziz, Haji Gul, Irfan Uddin, Georgios V. Gkoutos, Path-based extensions of local link
     prediction methods for complex networks. Sci. Rep., 10 (2020), 19848.
[3] Zhihao Dong, Yuanzhu Chen, Terrence S. Tricco, Cheng Li, Ting Hu, Hunting for vital nodes
     in complex networks using local information, Sci. Rep., 11 (2021), 9190.
[4] William L. Hamilton, Rex Ying, Jure Leskovec, Inductive representation learning on large
     graphs. NIPS’17: Proceedings of the 31st International Conference on Neural Information
     Processing Systems, (2017), 1025-1035.
[5] Tao Zhou, Progresses and challenges in link prediction. iScience, 24 (2021), 103217.
[6] A. Kanevsky, R. Tamassia, G. D. Battista, J. Chen, On-line maintenance of the four-
     connected components of a graph, In 32nd FOCS, (1991), 793-801.
[7] S. Alstrup, J. Holm, K. de Lichtenberg, M. Thorup, Maintaining information in fully dynamic
     trees with top trees, ACM Trans. Algorithm, 1 (2005), 243-264.
[8] S. Alstrup, J. Holm, M. Thorup, Maintaining center and median in dynamic trees. in: Proc.
     of the 8th Scandinavian Workshop on Algorithm Theory, (2000), 46-56.
[9] Hung-Lung Wang, Maintaining centdians in a fully dynamic forest with top trees, Discrete
     App. Math., 181 (2015), 310-315.
[10] H. N. Gabow, H. Kaplan, R. E. Tarjan, Unique maximum matching algorithms, J.
     Algorithms, 40 (2001), 159-183.
[11] J. Holm, K. de Lichtenberg, M. Thorup, Poly-logarithmic deterministic fully-dynamic
     algorithms for connectivity, minimum spanning tree, 2-edge and biconnectivity, J. ACM.,
     48 (2001), 723-760.
[12] E. Nardelli, G. Proietti, P. Widmayer, Finding all the best swaps of a minimum diameter
     spanning tree under transient edge failures, J. Graph Algorithms and Applications, 5 (2001),
     39-57.
                                                  60


[13] Julien Baste, Didem Gözüpek, Christophe Paul, Ignasi Sau, Mordechai Shalom, Dimitrios
     M. Thilikos, Parameterized complexity of finding a spanning tree with minimum reload
     cost diameter, Networks, 75 (2020), 259-277.
[14] Davide Bilò, Feliciano Colella, Luciano Gualà, Stefano Leucci, Guido Proietti, An Improved
     Algorithm for Computing All the Best Swap Edges of a Tree Spanner, Algorithmica, 82
     (2020), 279-299.
[15] Matteo Fischetti, Giuseppe Lancia, Paolo Serafini, Exact algorithms for minimum routing
     cost trees, Networks, 39 (2002), 161-173.
[17] Beat Gfeller, Nicola Santoro, Peter Widmayer, A Distributed Algorithm for Finding All Best
     Swap Edges of a Minimum-Diameter Spanning Tree, IEEE Transactions on Dependable
     and Secure Computing, 8 (2011), 1-12.
[18] Masayuki Kobayashi, Yoshio Okamoto, Submodularity of minimum-cost spanning tree
     games, Networks, 63 (2014), 231-238.
[19] Seth Pettie, Sensitivity analysis of minimum spanning trees in sub-inverse-Ackermann time,
     In Proc. of the 16th Intl. Symposium on Algorithms and Computation, (2005), 964-973.
[20] B.Y. Wu, G. Lancia, V. Bafna, K.-M. Chao, R. Ravi, C.Y. Tang, A polynomial time
     approximation scheme for minimum routing cost spanning trees, SIAM J. on Computing,
     29 (1999), 761-778.
[21] Davide Bilò, Luciano Gualà, Guido Proietti, Finding Best Swap Edges Minimizing the
     Routing Cost of a Spanning Tree, Algorithmica, 68 (2014), 337-357.
[22] B. Y. Wu, C. -Y. Hsiao, K.-M. Chao, The swap edges of a multiple-sources routing tree,
     Algorithmica, 50 (2008), 299-311.
[23] M. H. Khalifeh, Abdol-Hossein Esfahanian; A Faster Algorithm for Finding Best Swap Edges
     of multiple-source Routing Tree, submitted
[24] A. Meyerson, B. Tagiku, Minimizing Average Shortest Path Distances via Shortcut Edge
     Addition. Approximation, randomization, and combinatorial optimization, Algorithms and
     techniques. 12th international workshop, APPROX 2009, and 13th international workshop,
     RANDOM 2009, Berkeley, CA, USA, August 2123, (2009). Proceedings, 272-285.
[25] H. Wiener, Structural determination of the paraffin boiling points, J. Am. Chem. Soc., 69
     (1947), 17-20.
                                                   61


[26] Z. Shen, The average diameter of general tree structures, Comput. Math. Appl., 36 (1998),
     111-130.
[27] P. Dunklemann, R. C. Entringer, Average distance, minimum degree and spanning trees, J.
     Graph Theory, 33 (2000), 1-13.
[28] Roger C. Entringer, Douglas E. Jackson, D. A. Snyder, Distance in graphs, Czech. Math. J.,
     26 (1976), 283-296.
[29] B. D. McKay, The expected eigenvalue distribution of a large regular graph, Linear Algebra
     and its Applications, 40 (1981), 203-216.
[30] Davide Bilò, Luciano Gualà, Guido Proietti, A faster computation of all the best swap edges
     of a shortest paths tree, Algorithmica, 73 (2015), 547-570.
[31] B.Y. Wu, A polynomial time approximation scheme for the two-source minimum routing
     cost spanning trees, J. of Algorithms, 44 (2002), 359-378.
[32] B.Y. Wu, Approximation algorithms for the optimal p-source communication spanning tree,
     Discrete App. Math., 143 (2004), 31-42.
[33] M. H. Khalifeh, Abdol-Hossein Esfahanian, Discrete Integral and Discrete Derivative on
     Graphs and Switch problems of Trees, Mathematics, Advances in Graph Theory: Algorithms
     and Applications, 11 (2023), 1678.
                                                 62


                                                        APPENDIX
    Let 𝑇         be a tree and                 𝑎𝑥 ∈ 𝐸(𝑇). Then, using the definition ( 𝑘𝜎𝑇 (𝑣) =
∑𝑥∈𝑉(𝑇) 𝑑 𝑘𝑇 (𝑣, 𝑥), 𝑣 ∈ 𝑉(𝑇)):
                                                                                   2
          2
           𝜎𝑇 (𝑎) = ∑ 𝑑2𝑇 (𝑎, 𝑣) + ∑ [𝑑 2𝑇 (𝑥, 𝑣) + (𝑤(𝑎𝑥)) + 2𝑤(𝑎𝑥)𝑑 𝑇 (𝑥, 𝑣)],
                          𝑣∈𝑉(𝑇𝑎 )                𝑣∈𝑉(𝑇𝑥 )
                                                             2
          2
           𝜎𝑇 (𝑥) = ∑ [𝑑2𝑇 (𝑎, 𝑣) + (𝑤(𝑎𝑥)) + 2𝑤(𝑎𝑥)𝑑 𝑇 (𝑎, 𝑣)] + ∑ 𝑑 2𝑇 (𝑥, 𝑣).
                          𝑣∈𝑉(𝑇𝑎 )                                                         𝑣∈𝑉(𝑇𝑥 )
                                                         2
 2 ′
                 2
                  𝜎𝑇 (𝑥) − 2𝜎𝑇 (𝑎) (𝑤(𝑎𝑥)) [𝑛𝑇 (𝑇𝑎𝑥 ) − 𝑛𝑇 (𝑇𝑥𝑎 )] + 2𝑤(𝑎𝑥)[𝜎 𝑇𝑎𝑥 (𝑎) − 𝜎 𝑇𝑥𝑎 (𝑥)]
  𝜎𝑇 (𝑎𝑥
      ⃗⃗⃗⃗ ) =                             =
                        𝑤𝑇 (𝑎𝑥)                                             𝑤𝑇 (𝑎𝑥)
                                      = 𝑤(𝑎𝑥)𝜎𝑇′ (𝑎𝑥) + 2[𝜎 𝑇𝑎𝑥 (𝑎) − 𝜎 𝑇𝑥𝑎 (𝑥)]
    Also, one can use the same idea of Eq. 4.3 and see that,
  2
   𝐷′ (𝑇𝑥𝑦\𝑢𝑣 ) = 2𝐷(𝑇𝑥𝑦\𝑢𝑣 ) − 2𝐷(𝑇)
                        = 2[𝜎 𝑇𝑢𝑣 (𝑥)𝜎 𝑇𝑣𝑢 (𝑦) − 𝜎 𝑇𝑢𝑣 (𝑢)𝜎 𝑇𝑣𝑢 (𝑣)] + 𝑛𝑇 (𝑇𝑢𝑣 ). 𝑛𝑇 (𝑇𝑣𝑢 )[𝑤(𝑥𝑦) − 𝑤(𝑢𝑣)]
                        + 𝑛𝑇 (𝑇𝑣𝑢 ) [ 2𝜎 𝑇𝑢𝑣 (𝑥) − 2𝜎 𝑇𝑢𝑣 (𝑢)] + 𝑛𝑇 (𝑇𝑢𝑣 )[ 2𝜎 𝑇𝑣𝑢 (𝑦) − 2𝜎 𝑇𝑣𝑢 (𝑣)]
                        + 2𝑛𝑇 (𝑇𝑣𝑢 ) [𝜎 𝑇𝑢𝑣 (𝑥) − 𝜎 𝑇𝑣𝑢 (𝑢)] + 2𝑛𝑇 (𝑇𝑢𝑣 )[𝜎 𝑇𝑢𝑣 (𝑦) − 𝜎 𝑇𝑣𝑢 (𝑦)].
    We had that, 𝜎𝑇′ is consistence, thus by theorem 2.13,
               𝑥                                                        𝑦
            ∫    𝜎𝑇′𝑢𝑣 𝑑 𝑇𝑢𝑣 = 𝜎 (𝑥) − 𝜎 𝑇𝑢𝑣 (𝑢),
                                  𝑇𝑢𝑣                      and       ∫ 𝜎𝑇′𝑣𝑢 𝑑 𝑇𝑣𝑢 = 𝜎 𝑇𝑣𝑢 (𝑦) − 𝜎 𝑇𝑣𝑢 (𝑣).
              𝑢                                                        𝑣
    Therefore,
                                𝑥                            𝑦
   2  ′
    𝐷 (𝑇𝑥𝑦\𝑢𝑣 ) = 2 [(∫            𝜎𝑇′𝑢𝑣 𝑑𝑇𝑢𝑣 + 𝜎 𝑇𝑢𝑣 (𝑢))(∫ 𝜎𝑇′𝑣𝑢 𝑑 𝑇𝑣𝑢 + 𝜎 𝑇𝑣𝑢 (𝑣)) − 𝜎 𝑇𝑢𝑣 (𝑢)𝜎 𝑇𝑣𝑢 (𝑣)]
                               𝑢                            𝑣
                                            𝑥                             𝑦                              𝑥
                        + 𝑛𝑇 (𝑇𝑣𝑢 ) [∫ 2𝜎𝑇′𝑢𝑣 𝑑 𝑇𝑢𝑣 ] + 𝑛𝑇 (𝑇𝑢𝑣 ) [∫ 2𝜎𝑇′𝑣𝑢 𝑑 𝑇𝑣𝑢 ] + 2𝑛𝑇 (𝑇𝑢𝑣 ) [∫ 𝜎𝑇′𝑢𝑣 𝑑 𝑇𝑢𝑣 ]
                                           𝑢                             𝑣                              𝑢
                                              𝑦
                        + 2𝑛 𝑇 (𝑇𝑣𝑢 ) [∫ 𝜎𝑇′𝑣𝑢 𝑑 𝑇𝑣𝑢 ] + 𝑛𝑇 (𝑇𝑢𝑣 ). 𝑛𝑇 (𝑇𝑣𝑢 )[𝑤(𝑥𝑦) − 𝑤(𝑢𝑣)].
                                             𝑣
                                                               63


CHAPTER 5: DISTANCE PRESERVING GRAPHS AND 𝜹
     5.1 Introduction
     In this short chapter, we will have an asymptotic approach to problem 5, if 𝛿(𝐺) >
|𝑉(𝐺)|
       for the graph 𝐺, then it is dp. As mentioned, the result may help to minimize the
  2
potential mutations leading to a graph being dp. By definition, dh graphs are a subset of
sdp graphs, and dp graphs are a subset of dp graphs.
     Problem 5 comes from [8], which is minimal regarding the minimum degree of a graph
with dp property.
                                                                  𝑛
     Problem 3([8]): Let 𝐺 be an 𝑛‐vertex graph with 𝛿(𝐺) >         . Then 𝐺 is dp.       ▲
                                                                  2
     In contrast, we have the following result from [7].
                                                                    𝑛
     Proposition 5.1([7]): For any integer 𝑛 ≥ 5, and 2 ≤ 𝑟 < 2, where 𝑟 is even, there
exists an 𝑟‐regular graph on 𝑛 vertices without any isometric subgraph of order 𝑛 − 1.■
     The best known bound which implies that an 𝑛‐vertex graph 𝐺 is distance preserving
            2
is 𝛿(𝐺) ≥ 3 𝑛 − 1, see [7]. The graphs which satisfy that bound also have additional
properties [2,3,7]. Determining whether or not a graph is dh is linear [7]. That is an 𝑁𝑃‐
complete problem for the case of sdp [3]. For more detail and background, see [1,2,5,6].
We have an asymptotic approach to conjecture 5.1, that is, for graph 𝐺, if 𝛿(𝐺) > (1 +
   𝑛
𝜀) 2 and 𝜀 > 0, there is 𝑁 such that if |𝑉(𝐺)| > 𝑁, then 𝐺 is dp.
     In this chapter, by [𝑎, 𝑏], we mean the set of all integers of the interval. Also, when
there is no ambiguity, 𝛿 stands for 𝛿(𝐺) in a graph 𝐺.
     Lemma 5.2 ([7]): A graph 𝐺 has an isometric subgraph of order 𝑟, for any 𝑟 ∈
[1, ∆(𝐺) + 1].                                                                             ■
                                              64


     We use an estimation for 𝑛! using a continuous function.
     Lemma 5.3 (Sterling’s Approximation): Suppose 𝑛 is an integer. Then,
                                          𝑛 𝑛
                           𝑛! → √2𝜋𝑛 ( 𝑒 )         as 𝑛 → ∞.                                ■
     5.2 On Distance Preserving Conjecture
     Theorem 5.4: For every 𝜖 > 0 there is integer 𝑁 > 0 such that every graph 𝐺 with
                           1
𝑛 ≥ 𝑁 vertices and 𝛿 ≥ ( + 𝜀)𝑛 is dp.
                           2
                                                          𝑛
     Proof: Suppose 𝐺 is a graph on 𝑛 vertices and 𝛿 > 2. If 𝑣 ∈ 𝑉(𝐺) then for any set 𝐴
with {𝑣} ⊆ 𝐴 ⊆ 𝑁𝐺 [𝑣], 𝐻 = 𝐺[𝐴] is a subgraph of 𝐺 with diam(𝐻) ≤ 2. It is easy to see
that 𝐻 ≤ 𝐺. That guarantees that 𝐺 has an isometric subgraph of order 𝑘 for every 𝑘 ∈
[1, 𝛿 + 1], (also by lemma 5.2). As 𝐺 ≤ 𝐺, it remains to prove 𝐺 has an isometric subgraph
of order 𝑘 for every 𝑘 ∈ [𝛿 + 2, 𝑛 − 1] to conclude that 𝐺 is distance preserving. For 𝛿 >
𝑛 − 3, [𝛿 + 2, 𝑛 − 1] is empty; therefore, it is enough to consider the graphs 𝐺 with 𝛿 ∈
  𝑛                                                 𝑛
 [2 + 1, 𝑛 − 3]. And for a graph 𝐺 with 𝛿 ∈ [ 2 + 1, 𝑛 − 3], by Pigeonhole Principle,
diam(𝐺) = 2, and any induced non-isometric subgraph of 𝐺 has a diameter bigger than
two.
     Now assume toward a contradiction that 𝐺 does not have an isometric subgraph of
order 𝑘 for some 𝑘 ∈ [𝛿 + 2, 𝑛 − 1].
     Letting 𝑟 = 𝑛 − 𝑘, 𝑟 ∈ [1, 𝑛 − 𝛿 − 2], this assumption is equivalent to saying that
there is 𝑟 ∈ [1, 𝑛 − 𝛿 − 2] such that for every 𝐴 ∈ 𝑃𝑟 (𝑉(𝐺)) we have at least one pair
{𝑥, 𝑦} ⊆ 𝑉(𝐺 − 𝐴) with 𝑑𝐺−𝐴 (𝑥, 𝑦) > 2 and 𝑑𝐺 (𝑥, 𝑦) = 2. Such pairs will be called bad
pairs.
     Given such an 𝑟, we will find a lower bound for the number of distinct bad pairs. To
do this, we require to count the number of elements 𝐴 ∈ 𝑃𝑟 (𝑉(𝐺)) such that for a specific
                                                                       𝑛
pair {𝑥, 𝑦} ⊂ 𝑉(𝐺 − 𝐴) we have 𝑑𝐺−𝐴 (𝑥, 𝑦) > 2. First, note that 𝛿 >     forces 𝑆: = 𝑁𝐺 (𝑥) ∩
                                                                       2
 𝑁𝐺 (𝑦) ≠ ∅. In addition, if for 𝐴 ∈ 𝑃𝑟 (𝑉(𝐺)) we have 𝑑𝐺−𝐴 (𝑥, 𝑦) > 2 then it must be that
                                               65


𝑆 ⊆ 𝐴 and 𝑥𝑦 ∈ 𝐸(𝐺 𝑐 ). So given 𝑥, 𝑦, and thus 𝑆, the number of ways to pick an 𝑟-element
                                                                                           𝑛
set 𝐴 with 𝑆 ⊆ 𝐴 ⊆ 𝑉 − {𝑥, 𝑦} is exactly 𝑓|𝑆| = (𝑛−|𝑆|−2       𝑟−|𝑆|
                                                                      ). Moreover 𝛿 >          implies |𝑆| ≥
                                                                                           2
 2𝛿 − 𝑛 + 2, and it is easy to see that 𝑓|𝑆| is decreasing in this domain. Therefore for a
given 𝑟 and a pair 𝑥, 𝑦 ∈ 𝑉(𝐺), there are at most 𝑓2𝛿−𝑛+2 elements like 𝐴 ∈ 𝑃𝑟 (𝑉(𝐺)) such
that 𝑑𝐺 − 𝐴 (𝑥, 𝑦) > 2 in the graphs 𝐺 − 𝐴. This upper bound means we have at least
                                               |𝑃𝑟(𝑉(𝐺)) |           (𝑛𝑟)
                                𝑔(𝑛, 𝑟, 𝛿) = ⌊             ⌋ = ⌊ 2𝑛−2𝛿−4 ⌋
                                                𝑓2𝛿−𝑛+2         (          )
                                                                  𝑛+𝑟−2𝛿−2
    bad pairs. Moreover, we saw that bad pairs, 𝑥𝑦, belong to 𝐸(𝐺 𝑐 ). It follows that
                                              𝐸(𝐺 𝑐 ) ≥ 𝑔(𝑛, 𝑟, 𝛿).
    On the other hand, using the fact that summing the degrees of a graph gives twice
the number of edges,
                                                       𝑛
                                           |𝐸(𝐺 𝑐 )| ≤ (𝑛 − 𝛿 − 1).
                                                        2
                                                                                                𝑛
    We now wish to show that for every 𝑟 ∈ [1, 𝑛 − 𝛿 − 2], 𝑔(𝑛, 𝑟, 𝛿) > 2 (𝑛 − 𝛿 − 1)
which will result in a contradiction to the two previous inequalities. That implies that 𝐺
has at least one isometric subgraph of order 𝑘 for every 𝑘 ∈ [𝛿 + 2, 𝑛]. But instead we
                                            1
choose 𝑟′ = 𝑛 − 𝛿′ − 2 where 𝛿′ = (2 + 𝜀)𝑛 and 𝜖 is an appropriate positive number. Now
                                                      𝑛 𝑛
using Stirling's approximation, 𝑛! ≅ √2𝜋𝑛 ( 𝑒 ) , we can see that:
       ′    ′)
                   (𝑛−𝛿𝑛′ −2)        ∏1𝑖=0(𝑛 − 𝛿′ − 𝑖 ) ∏3𝑖=0(2𝑛 − 2𝛿 ′ − 𝑖)          𝑛! (2𝑛 − 3𝛿 ′ )!
 𝑔(𝑛, 𝑟 , 𝛿    =⌊               ⌋= ⌊                                             .                           ⌋
                  (2𝑛−2𝛿
                          ′ −4
                          ′   )         ∏2𝑖=1(𝛿 ′ + 𝑖) ∏3𝑖=0(2𝑛 − 3𝛿 ′ − 𝑖)        (𝑛 − 𝛿 ′ )! (2𝑛 − 2𝛿 ′ )!
                   2𝑛−3𝛿 −4
                                                                          𝑛
                                 𝑛                             𝑛          2
                                                                             −3𝜀 𝑛
                           √𝑛(
                                 2 − 3𝜀 𝑛)
                                                            𝑛
                                                          𝑛 ( 2 − 3𝜀 𝑛)
                   >                                           𝑛
                          𝑛                                      −𝜀 𝑛
                     √(       − 𝜀 𝑛) (𝑛 − 2𝜀 𝑛) (𝑛 − 𝜀 𝑛) 2           (𝑛 − 2𝜀 𝑛)𝑛 −2𝜀 𝑛
                          2                          2
                                                       66


                                                 1     𝑛
                                                  −3𝜀
                     𝜀
                                 1 − 6𝜀          2
                ≈ (4 . (                        )     ) .
                        1 − 6𝜀 + 12𝜀 2 − 8𝜀 3
     Therefore, choosing any 𝜀 > 0, 𝑔(𝑛, 𝑟 ′ , 𝛿 ′ ) ∝ 𝑐 𝑛 , for some 𝑐 > 1. And this means there
                                  𝑛
is 𝑁 such that 𝑔(𝑛, 𝑟 ′ , 𝛿 ′ ) > 2 (𝑛 − 𝛿 ′ − 1) ≥ |𝐸(𝐺 𝑐 )| when 𝑛 ≥ 𝑁. Surprisingly one can
see that 𝑔(𝑛, 𝑟′, 𝛿′) is decreasing on 𝑟 ′ ∈ [1, 𝑛 − 𝛿 − 2]. Accordingly, |𝐸(𝐺 𝑐 )| < 𝑔(𝑛, 𝑟′, 𝛿′)
for 𝑟 ′ ∈ [1, 𝑛 − 𝛿′ − 2], and this completes the proof.                                        ■
     Remark 5.5: One may require an estimation for 𝜀 and 𝑁. Using |𝐸(𝐺 𝑐 )| and the
                                        log𝑁
latest displayed inequality 𝜀 ≈ 𝑂(           ). But if we require the smallest 𝑁 regarding an 𝜀,
                                          𝑁
for actual goals, then we should find the smallest integer which confirms the function 𝑔 is
greater than the |𝐸(𝐺 𝑐 )|.                                                                    ▲
                                                    67


                                      REFERENCES
[1] V. Chepoi, Distance‐preserving subgraphs of Johnson graphs, Combinatorica, 37 (2017),
     1039-1055.
[2] V. Chepoi, On distance‐preserving and domination orderings, SIAM J. Discr. Math., 11
     (1998), 414-436.
[3] D. Coudert et al., Distance‐preserving orderings in graphs. RR‐8973, Inria Sophia
     Antipolis, (2016).
[4] G. Damiand, M. Habib, C. Paul, A simple paradigm for graph recognition: application to
     cographs and distance hereditary graphs, Theoretical Computer Science, 263 (2001), 99-
     111.
[5] D. Z. Djokovic, Distance‐preserving subgraphs of hypercubes, J. Combin. Theory Ser. B.,
     14 (1973), 263-267.
[7] R. L. Graham, P. M. Winkler, On isometric embeddings of graphs, Trans. Amer. Math.
     Soc., 288 (1985), 527-536.
[8] R. Nussbaum, Distance‐Preserving Graphs, Ph.D. Thesis, Diss. Michigan State University,
     2014.
[9] R. Nussbaum, Abdol-Hossein Esfahanian, Preliminary results on distance‐preserving
     graphs, Congressus Numerantium, 211 (2012), 141-149.
                                              68


CHAPTER 6: INSET EDGE OF TREES AND WIENER INDEX
     6.1 Introduction
     Average distance, degree distribution, and clustering coefficient are the three most
robust network topology measures. The sensitivity of the average distance of a network,
both after missing a link and adding a link, is interesting for researchers [3-7, 12].
     In this chapter, we work on simple graphs. By definition, an added edge to a graph is
an inset edge, which is a mutation. The average distance of a graph is the average of the
distances between every pair of vertices with finite distances [2]. Predicting 𝑘 > 1 inset
edges, which minimize the average distance of a simple graph, is known to be NP-Hard
[14], which is a polynomial problem for 𝑘 = 1. Solving the problem for the trees fast
enough may speed up the solution for the graphs’ inset edges via spanning tree sampling.
This chapter first establishes some tools for precisely analyzing the effect of inset edges
on the tree's average distance. Using the tools, one can avoid using the distance matrix
to help the better performance of algorithms. Then, some applications of the tools and a
tight bound for the change of average distance when an inset edge is added to a tree are
presented. The tools restrict the search space for finding the minimum gradient of average
distance. Afterward, we calculate the gradient of an inset edge on the average distance of
a tree for all edges. There is a heuristic algorithm for max{𝐷′(𝑇𝑒 )}𝑒∈𝐸(𝑇 𝑐) in problem 3,
where 𝑇 is replaced with a connected graph [19]. The time complexity of the algorithm
for trees is 𝑂(𝑛3 ) where there are 𝑛 vertices. We devised an exact algorithm that computes
and sorts the set {𝐷′(𝑇𝑒 )}𝑒∈𝐸(𝑇 𝑐) . The algorithms’ average time is 𝑂(𝑛2 . log 𝑛). A tree has
𝑂(𝑛2 ) inset edge, that is, the algorithm is minimal on average, where it significantly
reduces its former 𝑂(𝑛5 ) solution [20]. The algorithm is dynamic and recursively computes
                                                 69


the Wiener index (total distances) of all pseudotrees out of a tree. In fact, it calculates
the total distance of a pseudotree in 𝑂(log 𝑛)-time on average with the minimal possible
best time of 𝑂(1). Using established matrix tools, the algorithm strictly avoids extra
computations depending on the input trees’ topology. That results in a time complexity
proportional to the Wiener index of the input tree.
    6.2 Main Tools and Preliminary Results
                                                                                   −1
    As observed graph's average distance is equal to 𝐷(𝐺) = 𝑊(𝐺) · (|𝑉(𝐺)|     2
                                                                                 )    where 𝐺 is
a simple connected graph, [1,8,10-14,17-20]. By definition of gradient,
                                    (|𝑉(𝐺)|
                                        2
                                            )𝐷′ (𝐺𝑍 ) = 𝑊 ′ (𝐺𝑍 ).
    Accordingly, in this chapter, the results for 𝑊 hold for 𝐷 as well, with some constant
coefficient consideration.
    If 𝑇 is a tree and 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ), 𝑇𝑥𝑦\∅ is a mutation, and for ease, it is denoted by 𝑇𝑥𝑦 .
So, 𝑇𝑥𝑦 is a unicyclic graph, and 𝑥𝑦 is the inset edge. When we know the length of the
cycle of 𝑇𝑥𝑦 is 𝑘 we indicate it by 𝑇𝑥𝑦
                                      𝑘
                                         . Suppose 𝐶 is the cycle of 𝑇𝑥𝑦𝑘
                                                                          , we define:
                           𝐶𝑥 = { 𝑣 ∈ 𝑉(𝐶) | 𝑑 𝑇 (𝑥, 𝑣) < 𝑑 𝑇 (𝑦, 𝑣) },
                           𝐶𝑦 = { 𝑣 ∈ 𝑉(𝐶) | 𝑑 𝑇 (𝑥, 𝑣) > 𝑑 𝑇 (𝑦, 𝑣) },
                           𝐶𝑀 = { 𝑣 ∈ 𝑉(𝐶) | 𝑑 𝑇 (𝑥, 𝑣) = 𝑑 𝑇 (𝑦, 𝑣) }.
                               𝑘
    Note that |𝐶𝑥 | = |𝐶𝑦 | = ⌊2⌋, |𝐶𝑀 | = 0 when 𝑘 is even, and |𝐶𝑀 | = 1 otherwise. Now,
                                                      𝑘
index the element(s) of 𝐶𝑥 to 𝑥𝑖 '(s), 1 ≤ 𝑖 ≤ ⌊2⌋ in such a way that 𝑑 𝑇 (𝑥, 𝑥𝑖 ) = 𝑖 − 1.
                                                             𝑘
Similarly, index the element(s) of 𝐶𝑦 to 𝑦𝑖 '(s), 1 ≤ 𝑖 ≤ ⌊2⌋, in such a way that 𝑑 𝑇 (𝑦, 𝑦𝑖 ) =
𝑖 − 1.
    Moreover, if 𝐶𝑀 has the single element, we denote the element by 𝑥𝑀 .
                                                  70


     As we see, the indexing is unique and partitions the vertices of 𝐶. Additionally, for
𝑣 ∈ 𝑉(𝐶) suppose 𝑇𝑣 to be the maximal subtree of 𝑇𝑥𝑦 such that,
                                           𝑉(𝑇𝑣 ) ∩ 𝑉(𝐶) = {𝑣}.
     Informally, 𝑇𝑣 is the sub-tree attached to the vertex 𝑣 ∈ 𝑉(𝐶) with no other vertex
from 𝐶 except 𝑣. We denote the number of vertices of 𝑇𝑣 , |𝑉(𝑇𝑣 )|, by 𝑤𝑣 . See figure 6.1.
Figure 6.1 𝑇𝑥𝑦   𝑘
                    for even and odd k’s. A resolution to the indexing and maximal subtrees
     𝑇𝑥1        𝑥1           𝑦1       𝑇𝑦1               𝑇𝑥1        𝑥1         𝑦1      𝑇𝑦1
    𝑇𝑥2          𝑥2         𝑦2        𝑇𝑦2               𝑇𝑥2        𝑥2          𝑦2    𝑇𝑦2
    𝑇𝑥 𝑘         𝑥𝑘        𝑦𝑘          𝑇𝑦 𝑘              𝑇𝑥 𝑘       𝑥𝑘       𝑦𝑘     𝑇𝑦 𝑘
       ⌊ ⌋         ⌊ ⌋      ⌊ ⌋           ⌊ ⌋              ⌊ ⌋        ⌊ ⌋     ⌊ ⌋     ⌊ ⌋
        2           2        2             2                2          2       2       2
                                                                        𝑥𝑀
                                                                               𝑇𝑥𝑀
     Using the notations and definitions, we have the following theorem, which has a
critical role in our analysis and reduction of the time complexity of the actual calculations.
     Theorem 6.1: For a tree 𝑇,
                          𝑊 ′ (𝑇𝑥𝑦
                                𝑘
                                   )=      ∑       (2𝑑𝑇 (𝑢, 𝑣) − 𝑘) ⋅ 𝑤𝑢 ⋅ 𝑤𝑣
                                      (𝑢,𝑣)∈𝐶𝑥 ×𝐶𝑦
                                                 𝑘
                                       𝑑𝑇 (𝑢,𝑣)>
                                                 2
     Proof: Suppose 𝐶 is the cycle of 𝑇𝑥𝑦     𝑘
                                                . Using the definition of 𝑊 and our notations
                                                     71


      𝑘
  𝑊(𝑇𝑥𝑦  )=          ∑           𝑑 𝑇𝑥𝑦
                                     𝑘 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 )) +           ∑          𝑑 𝑇𝑥𝑦
                                                                                  𝑘 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 ))
              {𝑢,𝑣}⊆𝑉(𝐶𝑥 ∪ 𝐶𝑀 )                             {𝑢,𝑣}⊆𝑉(𝐶𝑦 ∪ 𝐶𝑀 )
          + ∑ 𝑑 𝑇𝑥𝑦       𝑘 (𝑉(𝑇𝑣 ), 𝑉(𝑇𝑣 )) +        ∑         𝑑 𝑇𝑥𝑦
                                                                    𝑘 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 ))
              𝑣∈𝑉(𝐶)                              (𝑢,𝑣)∈𝐶𝑥 ×𝐶𝑦
                                                             𝑘
                                                   𝑑𝑇 (𝑢,𝑣)≤
                                                             2
          +       ∑        𝑑 𝑇𝑥𝑦
                               𝑘 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 ))                                                     (6.1)
             (𝑢,𝑣)∈𝐶𝑥 ×𝐶𝑦
                       𝑘
              𝑑𝑇 (𝑢,𝑣)>
                        2
Looking at the updated distances from 𝑇 to 𝑇𝑥𝑦             𝑘
                                                               one can see that,
                                                                                (𝑢, 𝑣) ∈ 𝐶𝑥 × 𝐶𝑦
   𝑑𝑇𝑥𝑦
     𝑘 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 )) = 𝑑 𝑇 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 ))              except for                          𝑘 .
                                                                                   𝑑 𝑇 (𝑢, 𝑣) >
                                                                                                2
Therefore,
               𝑘
𝑊(𝑇) − 𝑊(𝑇𝑥𝑦     )=          ∑        𝑑𝑇 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 )) −         ∑       𝑑 𝑇𝑥𝑦
                                                                               𝑘 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 )). (6.2)
                       (𝑢,𝑣)∈𝐶𝑥 ×𝐶𝑦                            (𝑢,𝑣)∈𝐶𝑥 ×𝐶𝑦
                                  𝑘                                      𝑘
                         𝑑𝑇 (𝑢,𝑣)>                              𝑑𝑇 (𝑢,𝑣)>
                                   2                                      2
                                                                          𝑘
Besides, for every 𝑎 ∈ 𝑉(𝑇𝑢 ) and 𝑏 ∈ 𝑉(𝑇𝑣 ) if 𝑑 𝑇 (𝑢, 𝑣) > 2,
                                 𝑑𝑇 (𝑎, 𝑏) > 𝑑 𝑇𝑥𝑦𝑘 (𝑎, 𝑏),                                           (6.3)
                                 𝑑𝑇 (𝑎, 𝑢) = 𝑑 𝑇𝑥𝑦
                                                 𝑘 (𝑎, 𝑢),                                            (6.4)
                                𝑑 𝑇 (𝑏, 𝑣) = 𝑑𝑇𝑥𝑦𝑘 (𝑏, 𝑣).                                            (6.5)
More precisely, for equation 6.3, using the cycle of 𝑇𝑥𝑦             𝑘
                          𝑑𝑇 (𝑢, 𝑣) − 𝑑 𝑇𝑥𝑦𝑘 (𝑢, 𝑣) = 2 ⋅ 𝑑 𝑇 (𝑢, 𝑣) − 𝑘.
As we have, |𝑉(𝑇𝑢 )| = 𝑤𝑢 , and |𝑉(𝑇𝑣 )| = 𝑤𝑣 , by 6.3 to 6.5,
                                                    72


       𝑑𝑇 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 )) − 𝑑𝑇𝑥𝑦 𝑘 (𝑉(𝑇𝑢 ), 𝑉(𝑇𝑣 )) = (2. 𝑑 𝑇 (𝑢, 𝑣) − 𝑘) ⋅ 𝑤𝑢 ⋅ 𝑤𝑢                   (6.7)
                         𝑘
    where 𝑑𝑇 (𝑢, 𝑣) > 2. equations 6.2 and 6.7 lead us to,
                         𝑊 ′ (𝑇𝑥𝑦
                                𝑘
                                   )=         ∑       (2𝑑 𝑇 (𝑢, 𝑣) − 𝑘) ⋅ 𝑤𝑢 ⋅ 𝑤𝑣
                                        (𝑢,𝑣)∈𝐶𝑥 ×𝐶𝑦
                                                   𝑘
                                          𝑑𝑇 (𝑢,𝑣)>
                                                    2
    That completes the proof.                                                                              ■
    As a useful example of theorem 6.1, 𝑊 ′ (𝑇𝑢𝑣          3 )
                                                              = 𝑤𝑢 ⋅ 𝑤𝑣 . Also, note that by definition
1.4
                            𝑚𝑖𝑛𝑥𝑦∈𝐸(𝑇 𝑐) 𝑊 ′ (𝑇𝑥𝑦 ) = 𝑚𝑖𝑛𝑥𝑦∈𝐸(𝑇 𝑐) 𝑊(𝑇𝑥𝑦 ).
    We need to define some matrices to present some benefits of theorem 6.1. For ease
                       𝑘
hereafter, let 𝑘 ′ = ⌊2⌋.
    Suppose we are given a 𝑇𝑥𝑦     𝑘
                                     . We associate the vectors,           𝑥
                                                                          𝑥𝑦𝑾 or  𝑥
                                                                                 𝑥𝑦𝑾
                                                                                      𝑘      𝑥
                                                                                        = [ 𝑥𝑦 𝑤𝑖 ] to 𝑇𝑥𝑦𝑘
                                                                                                            ,
                                                                                                     𝑦
which is a 𝑘 ′ -vector and,   𝑥
                             𝑥𝑦𝑤𝑖   = 𝑤𝑥𝑖 = |𝑉(𝑇𝑥𝑖 )|, see figure 6.1. Similarly, we define         𝑥𝑦𝑾   or
 𝑦         𝑦               𝑦
𝑥𝑦𝑾
    𝑘
      = [ 𝑥𝑦𝑤𝑖 ] where    𝑥𝑦𝑤𝑖  = 𝑤𝑦𝑖 = |𝑉(𝑇𝑦𝑖 )|, 1 ≤ 𝑖 ≤ 𝑘 ′ , see figure 6.1. Then we associate
a matrix  𝒙𝒚𝑾    to 𝑇𝑥𝑦 as follows,
                                                    𝑥         𝑦
                                       𝑥𝑦𝑾      =  𝑥𝑦𝑾   × ( 𝑥𝑦𝑾)𝑡 .
                                                                  𝑦
    Therefore, in a     𝑥𝑦𝑾   = [𝑤𝑖𝑗 ]𝑘 ′ ×𝑘 ′ , 𝑤𝑖𝑗 =   𝑥
                                                        𝑥𝑦𝑤𝑖  ⋅  𝑥𝑦𝑤𝑗  = 𝑤𝑥𝑖 ⋅ 𝑤𝑦𝑗 . Next, we introduce
the matrix 𝑭𝑘 . The matrix 𝑭𝑘 is a 𝑘 ′ × 𝑘 ′ matrix as follows,
                                             𝑫𝑘 + 𝑶𝑘            𝑘 is odd,
                                    𝑭𝑘 = {
                                              𝑫𝑘            Otherwise.
    where 𝑫𝑘 = [𝑑𝑖𝑗 ] and 𝑶𝑘 = [𝑜𝑖𝑗 ] are also 𝑘 ′ × 𝑘 ′ matrices as follows,
                                                       73


                                 2(𝑘 ′ − 𝑖 − 𝑗 + 1)        𝑖 + 𝑗 ≤ 𝑘′,
                        𝑑𝑖𝑗 = {
                                 0                        otherwise.
and
                               1                        𝑖 + 𝑗 − 1 ≤ 𝑘′,
                      𝑜𝑖𝑗 = {
                                0                          otherwise.
For more resolution, see the following.
                   2𝑘 ′ − 1       2𝑘 ′ − 3        2𝑘 ′ − 5           …     1
                   2𝑘 ′ − 3       2𝑘 ′ − 5                      … 1        0
                   2𝑘 ′ − 5                               …   1      0     0
           𝑭𝑘 =                                      ⋮                              𝑘 is odd
                                       ⋮             1                      ⋮
                        ⋮             1             0                …     0
                 [      1             0             0          …     0      0]
        2𝑘 ′ − 2     2𝑘 ′ − 4        2𝑘 ′ − 6                      …    2      0
        2𝑘 ′ − 4     2𝑘 ′ − 6                                 …   2      0     0
        2𝑘 ′ − 6          ⋮                             … 2        0      0    0
                                            ⋮                                  0
 𝑭𝑘 =                                                                              𝑘 is even
                            ⋮               2
         ⋮                2                0                                    ⋮
           2              0                 0                              … 0
      [   0               0                0                      …       0    0 ]
                    1        1     1                               …   1
                    1        1                                …    1   0
                    1                                  …    1     0    0
           𝑶𝑘 =                                      ⋮
                                      ⋮             1                   ⋮
                     ⋮                    1            0           …    0
                  [ 1                    0             0    …     0      0 ]
                                      𝑤𝑥1
                                      𝑤𝑥2
                            𝑥𝑦𝑾   =           [𝑤𝑦1 𝑤𝑦2 … 𝑤𝑦 ′ ]
                                                                𝑘
                                         ⋮
                                    [𝑤𝑥𝑘′ ]
                                                 74


                𝑤𝑥1 . 𝑤𝑦1       𝑤𝑥1 . 𝑤𝑦2      𝑤𝑥1 . 𝑤𝑦3                 …                  𝑤𝑥1 . 𝑤𝑦 ′
                                                                                                      𝑘
                𝑤𝑥2 . 𝑤𝑦1       𝑤𝑥2 . 𝑤𝑦2           ⋮                    …                  𝑤𝑥2 . 𝑤𝑦 ′
                                                                                                      𝑘
                𝑤𝑥3 . 𝑤𝑦1              ⋮                                …                   𝑤𝑥3 . 𝑤𝑦 ′
                                                                                                      𝑘
          =            ⋮                     …                                                 ⋮
               𝑤𝑥 ′ . 𝑤𝑦1             …                                  ⋮                  𝑤𝑥 ′ . 𝑤𝑦 ′
                  𝑘 −2                                                                           𝑘 −2   𝑘
               𝑤𝑥 ′ . 𝑤𝑦1             …                 ⋮            𝑤𝑥 ′ . 𝑤𝑦 ′             𝑤𝑥 ′ . 𝑤𝑦 ′
                  𝑘 −1                                                    𝑘 −1     𝑘 −1          𝑘 −1    𝑘
            [ 𝑤𝑥𝑘′ . 𝑤𝑦1              …          𝑤𝑥 ′ . 𝑤𝑦
                                                     𝑘        𝑘′ −2
                                                                        𝑤𝑥 ′ . 𝑤𝑦 ′
                                                                             𝑘    𝑘 −1
                                                                                               𝑤𝑥 ′ . 𝑤𝑦 ′ ]
                                                                                                   𝑘    𝑘
                          𝑤11       𝑤12       𝑤13                 …                   𝑤1𝑘 ′
                         𝑤21        𝑤22             ⋮                    …            𝑤2𝑘 ′
                          𝑤31              ⋮                                          𝑤3𝑘 ′
                  =          ⋮                  …                                   ⋮
                          𝑤𝑘 ′ −2,1        …                                ⋮         𝑤𝑘 ′ −2,𝑘 ′
                          𝑤𝑘 ′ −1,1      …               ⋮           𝑤𝑘 ′ −1,𝑘 ′ −1   𝑤𝑘 ′ −1,𝑘 ′
                     [    𝑤𝑘 ′ ,1     …          𝑤𝑘 ′ ,𝑘 ′ −2      𝑤𝑘 ′ ,𝑘′ −1        𝑤𝑘 ′ ,𝑘 ′ ]
     In fact, 𝑭𝑘 is an upper-triangular matrix that provides the coefficients of 𝑤𝑢 . 𝑤𝑣 in the
formula of 𝑊 ′ in theorem 6.1. To express our next result, we recall the Hadamard
multiplication and the norm one of the matrices as follows. If 𝑨 = [𝑎𝑖𝑗 ] is a matrix, then
                                               ‖𝑨‖ = ∑𝑖,𝑗 |𝑎𝑖𝑗 | .
     The Hadamard product of two matrices 𝑨 = [𝑎𝑖𝑗 ] and 𝑩 = [𝑏𝑖𝑗 ] with equal dimensions
is an element-wise product that produces a matrix with the exact dimensions of 𝑨 and 𝑩
as follows,
                                        𝑪 = 𝑨 ⊚ 𝑩 = [𝑐𝑖𝑗 = 𝑎𝑖𝑗 ⋅ 𝑏𝑖𝑗 ].
     Note also that 𝑒𝑖 denotes the 𝑖’th unit standard vector of proper length.
     Lemma 6.2: For a tree 𝑇, we have:
                                             𝑘
                                        𝑊′(𝑇𝑥𝑦  ) = ‖𝑭𝑘 ⊚ 𝑥𝑦𝑾‖.
                                                         75


     Proof: Suppose 𝐶 is the cycle of 𝑇𝑥𝑦     𝑘
                                                 and 𝑢, 𝑣 ∈ 𝑉(𝐶). According to the definition of
𝑭𝑘 and   𝑥𝑦𝑾  if the 𝑖𝑗’th entry of  𝑥𝑦𝑾   is 𝑤𝑢 ⋅ 𝑤𝑣 , then the 𝑖𝑗’th entry of 𝑭𝒌 is (2𝑑 𝑇 (𝑢, 𝑣) −
                     𝑘                        𝑘
𝑘), for 𝑑𝑇 (𝑢, 𝑣) > 2. And if 𝑑𝑇 (𝑢, 𝑣) ≤ 2 , then the corresponding entry of            𝑥𝑦𝑾  is zero.
Therefore, using the definition of Hadamard multiplication,
                       ‖𝑭𝑘 ⊚ 𝑥𝑦𝑾‖ =          ∑       (2𝑑𝑇 (𝑢, 𝑣) − 𝑘) ⋅ 𝑤𝑢 ⋅ 𝑤𝑣 ,
                                        (𝑢,𝑣)∈𝐶𝑥 ×𝐶𝑦
                                                   𝑘
                                         𝑑𝑇 (𝑢,𝑣)>
                                                   2
     By theorem 6.1, the RHS of the above equation is equal to 𝑊 ′ (𝑇𝑥𝑦          𝑘
                                                                                   ).               ■
     Remark 6.3: As defined, when we introduce a graph, 𝑇𝑥𝑦           𝑘
                                                                          we mean an inset edge 𝑥𝑦
is added to 𝑇, which has created a 𝑘-cycle. Since in the indexing of the cycle of 𝑇𝑥𝑦          𝑘
                                                                                                 ,𝑥=
𝑥1 and 𝑦 = 𝑦1 so 𝑇𝑥𝑦    𝑘
                          = 𝑇𝑥𝑘1𝑦1 . We fix the initial indexing. Then, we abuse the initial
indexing of the cycle of 𝑇𝑥𝑦 𝑘
                                 to say that the inset edge of 𝑇𝑥𝑘−1   2 𝑦1
                                                                            is 𝑥2 𝑦1 . That means we
remove 𝑥1 𝑦1 and add 𝑥2 𝑦1 to 𝑇𝑥𝑘1𝑦1 . That changes 𝑘 to 𝑘 − 1 as well. Also, based on the
initial indexing, 𝑇𝑥𝑘+1
                     0 𝑦1
                          means the inset edge is 𝑥0 𝑦1 where 𝑥0 is a neighbor of 𝑥1 except
                                                  𝑘−𝑖−𝑗+2
from 𝑥2 . A similar argument applies for, 𝑇𝑥𝑖 𝑦𝑗          , regarding the initial indexing of 𝑇𝑥𝑦𝑘
                                                                                                   .▲
     The next theorem gives the lower and upper bound of, 𝑊 ′ (𝑇𝑥𝑦             𝑘
                                                                                 ) over the set of all
trees with 𝑛 vertices. The upper bound is interesting since for a tree, 𝑇 with 𝑛 vertices,
(𝑛 − 1)2 ≤ 𝑊(𝑇) ≤ (𝑛3) [16].
     Theorem 6.4: For a tree 𝑇 with 𝑛 vertices,
                                                   𝑛3 𝑛2 9𝑛
                                1 ≤ 𝑊 ′ (𝑇𝑥𝑦 ) ≤      −      −    + 2.
                                                   16 32        8
     Moreover, the lower bound holds if and only if 𝑇 has two leaves with a distance of
two, and the inset edge connects them. The upper bound holds if and only if the following
holds,
                                                     76


     1. 𝑛 ≡ 0 𝑚𝑜𝑑 8, 𝑛 ≥ 16,
                                                                                         𝑛
     2. 𝑇 is formed by attaching an arbitrary vertex of an arbitrary tree with             vertices
                                                                                         4
                                                                                                 𝑛
to a leaf of a 𝑃𝑛+3 and attaching an arbitrary vertex of another arbitrary tree with
                 2                                                                               4
vertices to the other leaf of 𝑃𝑛+3 .
                                  2
     3. 𝑥𝑦 connects the leaves of 𝑃𝑛+3 in the tree formed in the previous step.
                                       2
         Figure 6.2 Estimate structure of trees admitting upper bound of theorem 6.4
     Proof: To prove the upper bound, consider the graph 𝑇𝑥𝑦         𝑘
                                                                        with a non-trivial 𝑇𝑥𝑖 , where
2 ≤ 𝑖 ≤ 𝑘′ and |𝑉 (𝑇 )| = 𝑛. Detach the elements of 𝑉(𝑇𝑥𝑖 )/{𝑥𝑖 } and attach them
arbitrarily to the vertices of 𝑇𝑥1 and name the formed graph 𝐺. By lemma 6.2, we can see
that if |𝑉(𝑇𝑥𝑖 )/{𝑥𝑖 }| = 𝑤,
                                                 𝑦    𝑡
𝑊 ′ (𝐺) = ‖𝑭𝑘 ⊚ ( 𝑥𝑦
                   𝑥
                      𝑾 + 𝑤 ⋅ 𝑒1 − 𝑤 ⋅ 𝑒𝑖 ) ⋅ ( 𝑥𝑦𝑾) ‖
                                                    𝑦                             𝑦  𝑡
                = 𝑊 ′ (𝑇𝑥𝑦
                        𝑘
                           ) + ‖𝑭𝑘 ⊚ ( 𝑤 ⋅ 𝑒1 ). ( 𝑥𝑦𝑾)𝑡 ‖ − ‖𝑭𝑘 ⊚ (𝑤 ⋅ 𝑒𝑖 ) ⋅ ( 𝑥𝑦𝑾) ‖.           (6.8)
     This is straightforward to check that,
                                           𝑦                                𝑦
                     ‖𝑭𝑘 ⊚ ( 𝑤 ⋅ 𝑒1 ) ⋅ ( 𝑥𝑦𝑾)𝑡 ‖ > ‖𝑭𝑘 ⊚ (𝑤 ⋅ 𝑒𝑖 ) ⋅ ( 𝑥𝑦𝑾)𝑡 ‖.
     Therefore by Eq. 6.8,
                                         𝑊 ′ (𝐺) > 𝑊 ′ (𝑇𝑥𝑦  𝑘
                                                               ).
     Consequently, since 𝑖 was arbitrary and 𝑖 ≠ 1:
                                                      77


   1: 𝑊 ′ (𝑇𝑥𝑦𝑘
                ) is maximum ⟹ ∀ 𝑇𝑥𝑖 , 2 ≤ 𝑖 ≤ 𝑘 ′ , is trivial.
   2: Likewise, 𝑊 ′ (𝑇𝑥𝑦  𝑘
                            ) is maximum ⟹ ∀ 𝑇𝑦𝑖 , 2 ≤ 𝑖 ≤ 𝑘 ′ , is trivial.
   Since the matrix,      𝑥𝑦𝑾    is independent of, 𝑤𝑥𝑀 ,
   3: 𝑊 ′ (𝑇𝑥𝑦𝑘
                ) is maximum ⟹ 𝑇𝑥𝑀 is trivial.
   Using facts 1 to 3,
   4: 𝑊 ′ (𝑇𝑥𝑦𝑘
                ) is maximum ⟹ ∀𝑣 ∈ 𝑉(𝐶)/{𝑥, 𝑦}, |𝑇𝑣 | = 𝑤𝑣 = 1 where 𝐶 is the cycle of 𝑇𝑥𝑦     𝑘
                                                                                                  .
                                            𝑦                      𝑡
That is,  𝑥
         𝑥𝑦𝑾    = [𝑤𝑥 , 1,1, … ,1]𝑡 and    𝑥𝑦𝑾   = [𝑤𝑦 , 1,1, … ,1] .
   5: Since |𝑉(𝐶)| = 𝑘 and |𝑉(𝑇)| = 𝑛, so, 𝑊 ′ (𝑇𝑥𝑦         𝑘
                                                              ) is maximum ⟹
                                     𝑤𝑥 + 𝑤𝑦 = 𝑛 − 𝑘 + 2.                                    (6.9)
   Using theorem 6.1 and Eq. 6.9, we can see that; 𝑊 ′ (𝑇𝑥𝑦           𝑘
                                                                         ) is maximum ⟹
                                               𝑛−𝑘+2 𝑛−𝑘+2
                                   𝑤𝑥 . 𝑤𝑦 = ⌊            ⌋⌈            ⌉.
                                                    2             2
   Consequently, by facts 1-5 and theorem 6.1, if 𝑊 ′ (𝑇𝑥𝑦                 𝑘
                                                                             ) is maximum and 𝑘 ≡
2 𝑚𝑜𝑑 4:(See appendix A for more details on calculations)
                     𝑛−𝑘+2 𝑛−𝑘+2                             1
    𝑊 ′ (𝑇𝑥𝑦𝑘
              )=⌊               ⌋⌈            ⌉ (𝑘 − 2) + (𝑘 − 2)(𝑘 − 4)(𝑛 − 𝑘 + 2)
                         2               2                   4
                   1                        1
                + (𝑘 − 4)(𝑘 − 6) − (𝑘 − 6)(𝑘 − 2) ,                                         (6.10)
                   2                        8
   and for 𝑘 ≡ 0 𝑚𝑜𝑑 4:
                    𝑛−𝑘+2 𝑛−𝑘+2                             1
    𝑊 ′ (𝑇𝑥𝑦𝑘
              )=⌊               ⌋⌈            ⌉ (𝑘 − 2) + (𝑘 − 2)(𝑘 − 4)(𝑛 − 𝑘 + 2)
                         2               2                  4
                   1                       1
                + (𝑘 − 4)(𝑘 − 6) − (𝑘 − 4)2 ,                                               (6.11)
                   2                       8
   and for odd 𝑘′𝑠:
                                                      78


                     𝑛−𝑘+2 𝑛−𝑘+2                          1                             1
      𝑊 ′ (𝑇𝑥𝑦
             𝑘
               )=⌊              ⌋⌈           ⌉ (𝑘 − 2) + (𝑘 − 3)2 (𝑛 − 𝑘 + 2) + (𝑘 − 5)2
                          2            2                  4                             2
                    1
                 − (𝑘 − 5)(𝑘 − 3).                                                              (6.12)
                    8
     Because 𝑛 = |𝑉(𝑇)| is a constant, 𝑊 ′ (𝑇𝑥𝑦     𝑘
                                                      ) in equations 6.10 to 6.12 is a function of
𝑘 = |𝐶|. To find the maximum of 𝑊 ′ (𝑇𝑥𝑦       𝑘
                                                 ) we can take its derivative w.r.t 𝑘 for each case
of 6.10 to 6.12 and find the critical points. To do this, we require to consider two
                                                                           𝑘 )
                                                                    𝜕𝑊 ′ (𝑇𝑥𝑦
                          𝑛−𝑘+2
possibilities. First, if         is an integer, then the roots of,                in equations 6.10 to
                            2                                          𝜕𝑘
6.12 are equal to the following, respectively,
                  𝑛2 + 2𝑛 − 24               𝑛2 − 2𝑛 − 24                    𝑛2 − 2𝑛 − 25
            𝑘1 =                  ,     𝑘2 =                   and 𝑘3 =                      .
                      2𝑛 − 7                      2𝑛 − 7                          2𝑛 − 7
                                                                                  𝑘 )
                                                                           𝜕𝑊 ′ (𝑇𝑥𝑦
                 𝑛−𝑘+2
     Second, if          is not an integer, then the critical points of               in equations 6.10
                    2                                                         𝜕𝑘
to 6.12 are, respectively.
                   𝑛2 + 2𝑛 − 26                 𝑛2 − 2𝑛 − 25               𝑛2 − 2𝑛 − 26
              𝑘1 =                  ,    𝑘2 =                  and 𝑘3 =                    .
                       2𝑛 − 7                      2𝑛 − 7                       2𝑛 − 7
     Now for, 𝑘𝑖 , 𝑖 = 1 , 2, 3, we require to use the values, ⌊𝑘𝑖 ⌋ 𝑜𝑟 ⌈𝑘𝑖 ⌉ to find the maximum
of, 𝑊 ′ (𝑇𝑥𝑦
           𝑘
             ) in their respective equations. After doing so, we observe that the maximum
reachable value is equal to
                                          𝑛3 𝑛2 9𝑛
                                              −     −     + 2.
                                          16 32         8
     That proves the upper bound. One can check that the described trees of the theorem
touch the above upper bound. Moreover, no other cases meet both the constraints 1 to 5
and the upper bound. The lower bound is evident because, according to theorem 6.1,
𝑊 ′ (𝑇𝑥𝑦
      𝑘
         ) ≥ 1 as we had:
                                                     79


                           𝑊 ′ (𝑇𝑥𝑦
                                  𝑘
                                     )=        ∑       (2𝑑 𝑇 (𝑢, 𝑣) − 𝑘) ⋅ 𝑤𝑢 ⋅ 𝑤𝑣 .
                                          (𝑢,𝑣)∈𝐶𝑥 ×𝐶𝑦
                                                    𝑘
                                           𝑑𝑇 (𝑢,𝑣)>
                                                     2
      On the other hand, if either of 𝑤𝑢 , 𝑤𝑣 𝑜𝑟 (2𝑑 𝑇 (𝑢, 𝑣) − 𝑘) is greater than 1, then
𝑊 ′ (𝑇𝑥𝑦
       𝑘
         ) > 1. That means the only trees that can touch the lower bound are the ones
described in the theorem. This completes the proof.                                                          ■
      Remark 6.5: The previous theorem gives the best upper bound of 𝑊 ′ (𝑇𝑥𝑦                      𝑘
                                                                                                      ) where
|𝑉(𝑇)| = 𝑛 ≥ 16, and 𝑛 is divisible by 8. Using the theorem’s proof, one can establish a
lower tight upper bound when 𝑛 ≢ 0 𝑚𝑜𝑑 8 or 𝑛 = 8. In fact, if 𝑊 ′ (𝑇𝑥𝑦                  𝑘
                                                                                           ) is maximum,
                                                                         𝑦
using I and II from theorem 6.4,         𝑥
                                        𝑥𝑦𝑾    = [𝑤𝑥 , 1,1, … ,1]𝑡 and  𝑥𝑦𝑾   = [𝑤𝑦 , 1,1, … ,1]. Moreover,
                       𝑛−𝑘+2     𝑛−𝑘+2
we had 𝑤𝑥 . 𝑤𝑦 = ⌊            ⌋⌈        ⌉. Thus, without loss of generality, we can let 𝑤𝑥 =
                          2         2
  𝑛−𝑘+2            𝑛−𝑘+2
⌊       ⌋ , 𝑤𝑦 = ⌈      ⌉. Note that the structure of 𝑇𝑥 and 𝑇𝑦 do not affect the maximum
    2                2
attainable 𝑊 ′ but the size of them. So their structures are arbitrary. By lemma 6.2,
                                    𝑦
𝑊 ′ (𝑇𝑥𝑦
       𝑘
         ) = ‖𝑭𝑘 ⊚ ( 𝑥𝑦  𝑥
                           𝑾 × ( 𝑥𝑦𝑾)𝑡 )‖. Thus, interested readers can calculate 𝑊 ′ (𝑇𝑥𝑦           𝑘
                                                                                                       ) using
the provided variables, and intuitively see that, if 𝑊 ′ (𝑇𝑥𝑦         𝑘
                                                                        ) is maximum, then
                                                          𝑛
                                                     𝑘≈ .
                                                          2
      Knowing the latter fact, one may find some finite alternatives close to 𝑘 (𝑘 ± 2, 𝑘 ±
1, and 𝑘) that satisfy the given conditions to help find an upper bound of 𝑊 ′ (𝑇𝑥𝑦               𝑘
                                                                                                     ) among
the 𝑛’s that was not discussed in theorem 6.4.                                                              ▲
      Suppose we are given a 𝑇𝑥𝑦      𝑘
                                         which means the inset edge is 𝑥1 𝑦1 . If we remove 𝑥1 𝑦1
and substitute with 𝑥2 𝑦2 then we have a (𝑘 − 2)-cycle in, 𝑇𝑥2𝑦2 . We can make just one
                                            𝑦
change to the vectors,       𝑥
                            𝑥𝑦𝑾      and   𝑥𝑦𝑾    and calculate 𝑊 ′ (𝑇𝑥2𝑦2 ). That lets us avoid some
                                                         80


recalculations, and thus we can save time. In the following two theorems, we present the
details.
                                                                                  𝑦
     Theorem 6.6: Suppose 𝑇 is a tree and the vectors,                    𝑥𝑦𝑾, 𝑥𝑦𝑾
                                                                           𝑥
                                                                                       and the matrix  𝑥𝑦𝑾   =
[𝑤𝑖𝑗 ] are associated with 𝑇𝑥𝑦      𝑘
                                       , where 𝑑 𝑇 (𝑥, 𝑦) > 4. Then 𝑊 ′ (𝑇𝑥𝑘2𝑦2 ) ≥ 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) if and only
if:
                               ∑         𝑤𝑖𝑗 ≥ 𝑤11                              𝑘 is even ,
                          4≤𝑖+𝑗≤𝑘 ′ +1
                              𝑖,𝑗>1
                          2(      ∑        𝑤𝑖𝑗 ) +      ∑      𝑤𝑖𝑗 ≥ 2𝑤11         𝑘 is odd.
                             4≤𝑖+𝑗≤𝑘 ′ +1           𝑖+𝑗=𝑘 ′ +2
                        {        𝑖,𝑗>1                 𝑖,𝑗>1
     Proof: Suppose we have 𝑇𝑥𝑘1 𝑦1 and 𝑑 𝑇 (𝑥1 , 𝑦1 ) > 4. If we remove 𝑥1 𝑦1 from 𝑇𝑥𝑘1 𝑦1 and
add 𝑥2 𝑦2 to 𝑇 regarding the indexing of 𝐶𝑥1 and 𝐶𝑦1 in 𝑇𝑥𝑘1 𝑦1 , then we reach 𝑇𝑥𝑘−2                     2 𝑦2
                                                                                                               .
Therefore,
                                         𝑥2          𝑥1              𝑥
                                       𝑥2 𝑦2 𝑾  =  𝑥1 𝑦1 𝑾[2: ] + 𝑥1𝑦11 𝑤1 ⋅ 𝑒1 ,
     and
                                         𝑦2          𝑦1              𝑦
                                       𝑥2 𝑦2 𝑾  =  𝑥1 𝑦1 𝑾[2: ] + 𝑥1𝑦11 𝑤1 ⋅ 𝑒1 .
                                                          𝑦2         𝑥
     Moreover, we know that                𝑥2 𝑦2 𝑾 =   𝑥2 𝑦2 𝑾 × ( 𝑥2𝑦22 𝑾)𝒕 . Therefore, using lemma 6.2,
𝑊 ′ (𝑇𝑥𝑘−2
        2 𝑦2
             ) − 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) = ‖𝑭𝑘−2 ⊚ 𝑥2𝑦2 𝑾‖ − ‖𝑭𝑘 ⊚ 𝑥1𝑦1𝑾‖.                   Expanding    the     latter
equation using the definitions for odd and even 𝑘 separately, one can see that (see
appendix B: for more details of the calculation)
                                                             81


                                                   ∑        𝑤𝑖𝑗 − 𝑤11                             𝑘 is even,
                                               4≤𝑖+𝑗≤𝑘 ′ +1
                                                  𝑖,𝑗>1
         ′
       𝑊   (𝑇𝑥𝑘−2
               2 𝑦2
                    ) −𝑊 ′
                           (𝑇𝑥𝑘1𝑦1 ) =
                                            2(      ∑        𝑤𝑖𝑗 ) +    ∑        𝑤𝑖𝑗 − 2𝑤11          𝑘 is odd.
                                                4≤𝑖+𝑗≤𝑘 ′ +1         𝑖+𝑗=𝑘 ′ +2
                                          {        𝑖,𝑗>1               𝑖,𝑗>1
     This completes the proof.                                                                                      ■
     In the following theorem, we compute 𝑊 ′ (𝑇𝑥2𝑦1 ) using 𝑊 ′ (𝑇𝑥1 𝑦1 )Regarding the
indexing of 𝐶𝑥1 and 𝐶𝑦1 . That is, we remove 𝑥1 𝑦1 from 𝑇𝑥1 𝑦1 and insert the edge 𝑥2 𝑦1 to
the 𝑇.
                                                                                    𝑦
     Theorem 6.7: Suppose 𝑇 is a tree and the vectors                      𝑥𝑦𝑾, 𝑥𝑦𝑾
                                                                             𝑥
                                                                                           and the matrix      𝑥𝑦𝑾 =
[𝑤𝑖𝑗 ] are associated with 𝑇𝑥𝑦     𝑘
                                      , where 𝑑 𝑇 (𝑥, 𝑦) > 3. Then 𝑊 ′ (𝑇𝑥𝑘−1      2 𝑦1
                                                                                        ) ≥ 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) if and only
if,
                                      ∑          𝑤𝑖𝑗 ≥      ∑ 𝑤1𝑗           𝑘 is even,
                                3≤𝑖+𝑗≤𝑘 ′ +1              0<𝑗<𝑘′
                                  𝑖>1, 𝑗<𝑘′
                                       ∑          𝑤𝑖𝑗 ≥      ∑ 𝑤1𝑗            𝑘 is odd.
                                 3≤𝑖+𝑗   ≤ 𝑘 ′ +1          0<𝑗≤𝑘′
                              {    𝑖>1, 𝑗<𝑘′
     Proof: Suppose we have 𝑇𝑥𝑘1 𝑦1 and 𝑑 𝑇 (𝑥1 , 𝑦1 ) > 3. By lemma 6.2,
                                                              𝑥            𝑦
                              𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) = ‖𝐹𝑘 ⊚ ( 𝑥1𝑦11 𝑾) ⋅ ( 𝑥1𝑦11 𝑾)𝑡 ‖,                             (6.13)
     and
                                                               𝑥            𝑦
                            𝑊 ′ (𝑇𝑥𝑘−1
                                     2 𝑦1
                                          ) = ‖𝐹𝑘−1 ⊚ ( 𝑥2𝑦21 𝑾) ⋅ ( 𝑥2𝑦11 𝑾)𝑡 ‖.                           (6.14)
     Note that changing the inset edge from 𝑥1 𝑦1 to 𝑥2 𝑦1 changes 𝑘 to 𝑘 − 1, and 𝑭𝑘 varies
for odd and even 𝑘′𝑠. But, it is interesting to see that for both even and odd 𝑘’s:
                                                             82


                     𝑥              𝑦                                    𝑥         𝑥           𝑥
      ‖𝐹𝑘−1 ⊚ ( 𝑥2𝑦21 𝑾) ⋅ ( 𝑥2𝑦11 𝑾)𝑡 ‖ = ‖(𝐹𝑘 + 𝑂𝑘 ) ⊚ ( 𝑥1 𝑦11𝑾 − 𝑥1 𝑦11𝑤1 ⋅ 𝑒1 + 𝑥1𝑦11 𝑤1 ⋅
          𝑦
𝑒2 ). ( 𝑥1𝑦11 𝑾)𝑡 ‖.
      The LHS of the above equation is equal to 𝑊 ′ (𝑇𝑥𝑘−1                  2 𝑦1
                                                                                 ). Expanding the RHS of the
above equation and the LHS of equation 6.13 for odd and even 𝑘’s, using the definitions
of involved matrices, gives (calculations are similar to that of theorem 6.6; see appendix
B: for a similar calculation)
                                                           ∑        𝑤𝑖𝑗 −   ∑ 𝑤1𝑗         𝑘 is even,
                                                       3≤𝑖+𝑗≤𝑘 ′ +1        0<𝑗<𝑘′
                                                        𝑖>1, 𝑗<𝑘′
               𝑊 ′ (𝑇𝑥𝑘−1
                       2 𝑦1
                            ) − 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) =
                                                            ∑         𝑤𝑖𝑗 − ∑ 𝑤1𝑗          𝑘 is odd.
                                                       3≤𝑖+𝑗 ≤ 𝑘 ′ +1       0<𝑗≤𝑘′
                                                     {   𝑖>1, 𝑗<𝑘′
      Therefore, 𝑊 ′ (𝑇𝑥𝑘−1   2 𝑦1
                                   ) ≥ 𝑊 ′ (𝑇𝑥𝑘1 𝑦1 ) if and only if,
                                         ∑         𝑤𝑖𝑗 ≥     ∑ 𝑤1𝑗           𝑘 is even,
                                     3≤𝑖+𝑗≤𝑘 ′ +1          0<𝑗<𝑘′
                                      𝑖>1, 𝑗<𝑘′
                                          ∑          𝑤𝑖𝑗 ≥    ∑ 𝑤1𝑗           𝑘 is odd.
                                     3≤𝑖+𝑗  ≤ 𝑘 ′ +1         0<𝑗≤𝑘′
                                  {    𝑖>1, 𝑗<𝑘′
      This completes the proof.                                                                            ■
      The following results show some applications of theorems 6.6 and 6.7. That is, we can
almost ignore the edges of a tree 𝑇 that share a vertex with a leaf when finding
  max 𝐷′ (𝑇𝑥𝑦 ).
𝑥𝑦∈𝐸(𝑇 𝑐 )
      Corollary 6.8: Suppose 𝑇 is a tree on 𝑛 > 6 vertices and 𝑇 ≇ 𝑆𝑛 . Then there is 𝑢𝑣 ∈
𝐸(𝑇 𝑐 ) where 𝑢 and 𝑣 are not both leaves and, 𝑊 ′ (𝑇𝑢𝑣 ) = max 𝑐 𝑊 ′ (𝑇𝑎𝑏 ).
                                                                               𝑎𝑏∈𝐸(𝑇 )
                                                               83


     Proof: Suppose we are given a 𝑇𝑥𝑦             𝑘
                                                       such that 𝑑𝑒𝑔(𝑥) = 𝑑𝑒𝑔(𝑦) = 1. That means
 𝑤𝑥1 = 𝑤𝑦1 = 1 and so 𝑤11=1. For the proof of corollary, it is sufficient to show that for
any 𝑘 > 2 there is 𝑢𝑣 ∈ 𝐸(𝑇) such that 𝑢 or 𝑣 are not both leaves and 𝑊 ′ (𝑇𝑢𝑣 ) ≥
𝑊 ′ (𝑇𝑥𝑘1𝑦1 ). If 𝑘 > 5, then by theorem 6.6 we clearly have, 𝑊 ′ (𝑇𝑥𝑘−2                 2 𝑦2
                                                                                              ) ≥ 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ), where
𝑥2 and 𝑦2 are not leaves. For the remaining finite cases, 𝑘 = 5,4,3, we assume that 𝑤𝑥 =
 𝑤𝑦 = 1, 𝑛 > 6 and 𝑇 ≇ 𝑆𝑛 . Accordingly, if 𝑘 = 4, then 𝑊 ′ (𝑇𝑥𝑘−1                2 𝑦1
                                                                                       ) ≥ 𝑊 ′ (𝑇𝑥𝑘1 𝑦1 ) = 2 and 𝑥2
is not a leaf. If 𝑘 = 5, we observe that either, 𝑊 ′ (𝑇𝑥𝑘−1            2 𝑦1
                                                                            ) or, 𝑊 ′ (𝑇𝑥𝑘−11 𝑦2
                                                                                                 ) or, 𝑊 ′ (𝑇𝑥𝑘−2
                                                                                                               𝑀 𝑦1
                                                                                                                    ) or,
𝑊 ′ (𝑇𝑥𝑘−2
        𝑀 𝑥1
             ) or, 𝑊 ′ (𝑇𝑥𝑘−2
                           2 𝑦2
                                ) is greater than 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) and 𝑥2 , 𝑦2 or, 𝑥𝑀 are not leaves (see
appendix C: for more detail). If 𝑘 = 3, 𝑊 ′ (𝑇𝑧𝑦         𝑘−1
                                                           1
                                                              ) ≥ 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) = 1, where 𝑧 is any non-leaf
vertex. This completes the proof.                                                                                      ■
     Theorem 6.9: Suppose 𝑣 is a leaf of a tree 𝑇 and 𝑧 ∈ 𝑉(𝑇) is arbitrary. If 𝑑 𝑇 (𝑣, 𝑧) ∈
ℕ/{2,3,4,6}, then either a non-leaf 𝑥 ∈ 𝑉(𝑇) exists such that 𝑊 ′ (𝑇𝑣𝑧 ) ≤ 𝑊 ′ (𝑇𝑥𝑧 ) or the
non-leaves 𝑥, 𝑦 ∈ 𝑉(𝑇) exist such that 𝑊 ′ (𝑇𝑣𝑧 ) ≤ 𝑊 ′ (𝑇𝑥𝑦 ).
     Proof: We break the proof into two claims, which cover the theorem conditions.
     Claim (1): If 𝑣 is a leaf of 𝑇, 𝑑𝑇 (𝑣, 𝑧) = 𝑘 − 1, 𝑘 > 4 and, 𝑘 is even; then there exist
a non-leaf 𝑢 ∈ 𝑉(𝑇) such that 𝑊 ′ (𝑇𝑣𝑧 ) ≤ 𝑊 ′ (𝑇𝑢𝑧 ).
     Proof of Claim (1): By theorem 6.7's proof:
                         𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) − 𝑊 ′ (𝑇𝑣𝑘−1
                                                2 𝑧1
                                                     )=         ∑           𝑤𝑖𝑗 −      ∑ 𝑤1𝑗 .                  (6.15)
                                                           3≤𝑖+𝑗  ≤ 𝑘 ′ +1           0<𝑗<𝑘 ′
                                                             𝑖>1, 𝑗<𝑘 ′
     Since deg(𝑣) = 1, so by definition           𝑣
                                                 𝑣𝑧𝑤1    = 1 and
                                                      𝑧
                                              ∑      𝑣𝑧 𝑤𝑗  = ∑ 𝑤1𝑗 .                                            (6.16)
                                            0<𝑗<𝑘 ′            0<𝑗<𝑘 ′
     Thus, by the definition of         𝑣𝑧𝑾,  for 𝑘 ′ ≥ 3,
                                                          84


                                               𝑧                                                            (6.17)
                                       ∑      𝑣𝑧𝑤𝑗 = ∑ 𝑤1𝑗 ≤                    ∑           𝑤𝑖𝑗 .
                                     0<𝑗<𝑘 ′          0<𝑗<𝑘 ′             3≤𝑖+𝑗    ≤ 𝑘 ′ +1
                                                                           𝑖>1, 𝑗<𝑘 ′
     and using equations 6.15 and 6.17,
                                                               𝑊′(𝑇𝑣𝑘1𝑧1 ) ≤ 𝑊 ′ (𝑇𝑣𝑘−1    2 𝑧1
                                                                                                ),
     where 𝑣2 is not a leaf.
     Claim (2): If 𝑣 is a leaf of 𝑇, 𝑑 𝑇 (𝑣, 𝑧) = 𝑘 − 1, 𝑘 > 7 and, 𝑘 is odd, then either a
non-leaf 𝑥 ∈ 𝑉(𝑇) exists such that, 𝑊 ′ (𝑇𝑣𝑧 ) ≤ 𝑊 ′ (𝑇𝑥𝑧 ) or the non-leaves 𝑥, 𝑦 ∈ 𝑉(𝑇) exist
such that, 𝑊 ′ (𝑇𝑣𝑧 ) ≤ 𝑊 ′ (𝑇𝑥𝑦 ).
     Proof of Claim (2): The proof for the odd 𝑘’s is tricky and needs a precise comparison.
First, by theorem 6.7's proof, we know that,
                               𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) − 𝑊 ′ (𝑇𝑣𝑘−1
                                                        2 𝑧1
                                                              )=        ∑           𝑤𝑖𝑗 − ∑ 𝑤1𝑗 ,            (6.18)
                                                                    3≤𝑖+𝑗 ≤ 𝑘 ′ +1            0<𝑗≤𝑘 ′
                                                                      𝑖>1,𝑗<𝑘 ′
     and by theorem 6.6's proof,
             𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) − 𝑊 ′ (𝑇𝑣𝑘−22 𝑧2
                                            ) = 2(     ∑          𝑤𝑖𝑗 ) +        ∑        𝑤𝑖𝑗 − 2𝑤11 .        (6.19)
                                                   4≤𝑖+𝑗≤𝑘 ′ +1             𝑖+𝑗=𝑘 ′ +2
                                                      𝑖,𝑗>1                     𝑖,𝑗>1
     Assuming,           𝑣
                        𝑣𝑧𝑾     = [1,1, … ,1]𝑡 ,      𝑧
                                                     𝑣𝑧𝑾     = [𝑎𝑖 ]𝑘 ′     and          expanding     Eq. 6.18    if
𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) ≥ 𝑊 ′ (𝑇𝑣𝑘−1 2 𝑧1
                                ), then by theorem 6.7 (see appendix C fo detail)
                                                           𝑘 ′ −1
                                                 𝑎𝑘 ′ ≥ ∑ (𝑘 ′ − 𝑖)𝑎𝑖 ,                                      (6.20)
                                                            𝑖=1
     Similarly assuming,              𝑣
                                     𝑣𝑧𝑾    = [1,1, … ,1]𝑡 ,      𝑧
                                                                 𝑣𝑧𝑾   = [𝑎𝑖 ]𝑘 ′ and expanding Eq. 6.19 if
𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) ≥ 𝑊 ′ (𝑇𝑣𝑘−2 2 𝑧2
                                ), then by theorem 6.6 (see appendix C for detail)
                                                                85


                                                    𝑘′
                                          2𝑎1 ≥ ∑(2𝑘 ′ − 2𝑖 + 1)𝑎𝑖 .                                               (6.21)
                                                   𝑖=2
      It is straightforward to see that if 𝑘 ′ ≥ 4, then either (20) or (21) does not hold. That
is, if (20) holds, then (21) does not happen, and if (21) occurs, then (20) does not hold.
Moreover, it is easy to see if                𝑣
                                             𝑣𝑧𝑾   ≠ [1,1, … ,1]𝑡 then the RHS of (20) and (21) will be
greater, not harming our argument. Consequently, using (18) and (19), either
𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) ≤ 𝑊 ′ (𝑇𝑣𝑘−1 2 𝑧1
                                ) or 𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) ≤ 𝑊 ′ (𝑇𝑣𝑘−2   2 𝑧2
                                                                       ), where 𝑣2 and 𝑧2 do not represent
leaves. This completes the proof.                                                                                       ■
      Remark 6.10: By corollary 6.8 and theorem 6.9, except for some specified cases,
there exists an inset edge between two non-leaf vertices of a tree, which minimizes the
average distance of a tree. In fact, using the following result by Renyi,
      Proposition 6.11: The expected number of leaves in a random labeled tree on 𝑛
vertices is 𝑛/𝑒 where 𝑒 is the Euler's number.                                                                          ■
                                                                                                            𝑛−𝑛
      one can limit our search space from (𝑛2) − |𝐸(𝑇)| inset edges to nearly (                                2
                                                                                                                 𝑒) inset
                                                                                       𝑛
                                                                                    𝑛−
                                                                                  (    𝑒)
                                                                                     2              𝑒−1 2
edges, when seeks               min 𝑐 𝑊 ′ (𝑇𝑥𝑦 ). That eliminates 1 −               (𝑛
                                                                                           ≈ 1−(       ) ≈ %60 of
                             𝑥𝑦∈𝐸(𝑇 )                                                2)              𝑒
potential inset edges for            min 𝑊 ′ (𝑇𝑥𝑦 ).                                                                   ▲
                                   𝑥𝑦∈𝐸(𝑇 𝑐 )
      The next theorem is another application of theorems 6.6 and 6.7 to an efficient
algorithm.
      Theorem 6.12: Suppose 𝑇 is a tree, 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ) and 𝑑 𝑇 (𝑥, 𝑦) = 𝑘 − 1. If we are given
                                𝑦
the vectors     𝑥
               𝑥𝑦𝑾      and    𝑥𝑦𝑾,   then we can obtain the following
             {𝑊 ′ (𝑇𝑥𝑘−2𝑖+2
                      𝑖 𝑦𝑖
                                )}            ∪ {𝑊 ′ (𝑇𝑥𝑘−2𝑖+1
                                                         𝑖+1 𝑦𝑖
                                                                 )}           ∪ {𝑊 ′ (𝑇𝑥𝑘−2𝑖+1
                                                                                         𝑖 𝑦𝑖+1
                                                                                                )}           ,
                                  1≤𝑖≤𝑘 ′ −1                       1≤𝑖≤𝑘 ′ −1                     1≤𝑖≤𝑘 ′ −1
      using 𝑂(𝑘 2 ) operations.
                                                                               𝑦
      Proof: Suppose we have 𝑇𝑥𝑦             𝑘
                                                , 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ),    𝑥
                                                                  𝑥𝑦𝑾    and  𝑥𝑦𝑾.   Using lemma 6.2,
                                                                86


                                                                          𝑦
                                    𝑊 ′ (𝑇𝑥𝑦  𝑘
                                                ) = ‖𝑭𝑘 ⊚ ( 𝑥𝑦 𝑥
                                                                 𝑾 × ( 𝑥𝑦𝑾)𝑡 )‖.
      Thus, it costs us 𝑂(𝑘 2 ) operations to calculate, 𝑊 ′ (𝑇𝑥𝑦             𝑘
                                                                                 ), 𝑥𝑦𝑾,    and ‖𝑶𝒌 ⊚ 𝑥𝑦𝑾‖. By
theorem 6.6, if 𝑘 is even, then
                             𝑊 ′ (𝑇𝑥𝑘−2
                                     2 𝑦2
                                          ) − 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) =      ∑       𝑤𝑖𝑗 − 𝑤11 .                           (6.22)
                                                              4≤𝑖+𝑗≤𝑘 ′ +1
                                                                  𝑖,𝑗>1
      and by definitions of 𝑶𝑘 and              𝑥𝑦𝑾,
                        ∑      𝑤𝑖𝑗 − 𝑤11 = ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ − ∑ 𝑤𝑖1 − ∑ 𝑤1𝑖 .                                          (6.23)
                  4≤𝑖+𝑗≤𝑘 ′ +1                                        1≤𝑖≤𝑘 ′        1≤𝑖≤𝑘 ′
                       𝑖,𝑗>1
      Since we already have ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ and 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ), by (6.22) and (6.23) we obtain
                                                                                                            𝑦
𝑊 ′ (𝑇𝑥𝑘−2
         2 𝑦2
              ) in 𝑂(𝑘)-time. Moreover, having                 𝑥𝑦𝑾,     ‖𝑶𝒌 ⊚ 𝑥𝑦𝑾‖,          𝑥𝑦𝑾,
                                                                                              𝑥
                                                                                                    and    𝑥𝑦𝑾,     the
following calculations clearly take at most 𝑂(𝑘)-time to compute,                       𝑥2 𝑦2 𝑾, ‖𝑶𝑘−2 ⊚ 𝑥2𝑦2 𝑾‖,
  𝑥2               𝑦2
𝑥2 𝑦2 𝑾,    and  𝑥2 𝑦2 𝑾
      1-By definition
                           ‖𝑶𝑘−2 ⊚ 𝑥2 𝑦2𝑾‖ = ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ − ∑ (𝑤𝑖1 +𝑤1𝑖 ) −                          ∑       𝑤𝑖𝑗 .
                                                                        1≤𝑖≤𝑘 ′                 𝑖+𝑗=𝑘 ′ +2
      2-Changing the first and second columns and rows of                       𝑥𝑦𝑾
      𝑥2 𝑦2 𝑾   = 𝑥𝑦𝑾[𝟐: , 𝟐: ]
                         𝑥                                      𝑦
                  +( 𝑥𝑦    𝑾[𝟐: ]𝑤𝑦 as the first row) + ( 𝑥𝑦𝑾[𝟐: ]𝑤𝑥 as the first column)
      3-By definition
                                            𝑥2         𝑥              𝑥
                                          𝑥2 𝑦2 𝑾 =   𝑥𝑦𝑾[2: ]  + 𝑥1𝑦11𝑤1 ⋅ 𝑒1 ,
      and
                                            𝑦2         𝑦              𝑦
                                          𝑥2 𝑦2 𝑾 =   𝑥𝑦𝑾[2: ]  + 𝑥1𝑦11𝑤1 ⋅ 𝑒1 .
                                                             87


                                                                        𝑥3      𝑦3
     Similarly, we can obtain 𝑊 ′ (𝑇𝑥𝑘−4           3 𝑦3
                                                        ), 𝑥3 𝑦3 𝑾, 𝑥3 𝑦3 𝑾, 𝑥3 𝑦3 𝑾,   and ‖𝑶𝒌−𝟒 ⊚ 𝑥3 𝑦3𝑾‖ with
                                                             𝑥2         𝑦2
𝑂(𝑘) operations from, 𝑊 ′ (𝑇𝑥𝑘−2       2 𝑦2
                                            ),   𝑥2 𝑦2 𝑾, 𝑥2 𝑦2 𝑾, 𝑥2 𝑦2 𝑾,   and ‖𝑶𝒌−𝟐 ⊚ 𝑥2 𝑦2𝑾‖. That is, we
can obtain, {𝑊 ′ (𝑇𝑥𝑘−2𝑖+2
                       𝑖 𝑦𝑖
                                 )}              in 𝑂(𝑘 × 𝑘)-time. A similar argument applies to odd 𝑘′s
                                   1≤𝑖≤𝑘 ′ −1
according to theorem 6.6. By using theorem 6.7, similarly, we can compute
{𝑊 ′ (𝑇𝑥𝑘−2𝑖+1
         𝑖+1 𝑦𝑖
                )}           and {𝑊 ′ (𝑇𝑥𝑘−2𝑖+1
                                              𝑖 𝑦𝑖+1
                                                        )}           in 𝑂(𝑘 2 )-time. This completes the proof.■
                  1≤𝑖≤𝑘 ′ −1                              1≤𝑖≤𝑘 ′ −1
     Remark 6.13: The average diameter of a tree 𝑇 on 𝑛 vertices, is 𝑙𝑜𝑔(𝑛) [15]. On the
other hand, by theorem 6.12, we obtained {𝑊 ′ (𝑇𝑥𝑘−2𝑖+2                𝑖 𝑦𝑖
                                                                             )}           in 𝑂(𝑘 2 )-time. Thus, we
                                                                               1≤𝑖≤𝑘 ′ −1
can obtain each 𝑊 ′ (𝑇𝑥𝑘−2𝑖+2 𝑖 𝑦𝑖
                                      ), 1 ≤ 𝑖 ≤ 𝑘 ′ − 1, in 𝑂(𝑘)-time subject to the given condition.
Since 𝑘 < 𝑑𝑖𝑎𝑚(𝑇) + 1 and the number of inset edges is of 𝑂(𝑛2 ) we have the following
question:                                                                                                        ▲
     Question 6.14: Suppose 𝑇 is a tree on 𝑛 vertices. Is it possible to obtain
{𝑊(𝑇𝑥𝑦 )}𝑥𝑦∈𝐸(𝑇 𝑐) with the average time complexity of 𝑂(𝑛2 log(𝑛))?                                             ▲
6.3 Main Result: An algorithm For Inset Edge of Trees
     6.3.1 Some Tools to Divide and Conquer
     Definition 6.15: Suppose 𝐺 is a graph and 𝑢, 𝑣 ∈ 𝑉(𝐺). We define the relative
neighborhood of 𝑢 compared to 𝑣 as follows:
                                   𝑁𝐺𝑣 (𝑢) = {𝑥 ∈ 𝑉(𝐺) | 𝑑(𝑥, 𝑢) < 𝑑(𝑥, 𝑣)}.
     And let,
                                                       |𝑁𝐺𝑣 (𝑢)| = 𝑛𝐺𝑣 (𝑢) .                                     ▲
     Note that if 𝑇 is a tree on 𝑛 vertices, then for every 𝑢𝑣 ∈ 𝐸(𝑇), 𝑛𝑣𝑇 (𝑢) + 𝑛𝑢𝑇 (𝑣) = 𝑛,
and if 𝑥𝑖−1 , 𝑥𝑖 ∈ 𝐶𝑥 and 𝑦𝑖−1 , 𝑦𝑖 ∈ 𝐶𝑦 in a 𝑇𝑥𝑦            𝑘
                                                               , then
                                                  𝑥
                                                𝑛𝑇𝑖−1 (𝑥𝑖 ) = |𝑇𝑥𝑖 | = 𝑤𝑥𝑖 ,
     and
                                                  𝑦
                                                𝑛𝑇𝑖−1 (𝑦𝑖 ) = |𝑇𝑦𝑖 | = 𝑤𝑦𝑖 .
                                                                 88


     Definition 6.16: Each inset edge connects two vertices of a tree. The path that
connects the two vertices has a middle vertex/edge, which is the vertex/edge that has an
equal distance from the paths’ two endpoints. If the length of the path is even, then the
middle is a vertex, and the middle is an edge if the length is odd. We call the middle
vertex/edge of the path that connects the vertices of an inset edge of a tree the middle of
that inset edge.                                                                          ▲
     Note that a vertex/edge of a tree can be the middle of more than one inset edge. But
every inset edge has a unique middle. Moreover, a leaf or an edge incident with a leaf can
not be middle of any inset edge.
     Theorem 6.17: The set of inset edges of a tree, 𝐸(𝑇 𝑐 ), forms equivalence classes
regarding the middles. More precisely, each equivalence class is the inset edges of the tree
with the same middle.
     Proof: An inset edge forms a unique cycle in a tree. Therefore, every inset edge has
a unique middle. That partitions the inset edges into sets of inset edges with the same
middles. This completes the proof.                                                         ■
     Definition 6.18: Suppose the vertex/edge 𝑧 is the middle of the inset edge, 𝑥𝑦, which
means 𝑑(𝑧, 𝑥) = 𝑑(𝑧, 𝑦). If 𝑎𝑏 is another inset edge such that 𝑎𝑥 ∈ 𝐸(𝑇), 𝑏𝑦 ∈ 𝐸(𝑇), and
                         𝑑(𝑧, 𝑎) = 𝑑(𝑧, 𝑥) + 1 and 𝑑(𝑧, 𝑏) = 𝑑(𝑧, 𝑦) + 1,
     then we say 𝑎𝑏 is the next parallel edge of 𝑥𝑦.                                      ▲
     In definition 6.18; 𝑥𝑦, 𝑎𝑏, 𝑥𝑎, and 𝑦𝑏 induce a 𝐶4 , which is 𝑥𝑦𝑏𝑎𝑥. Using a different
point of view, if 𝑎 ∈ 𝑁(𝑥) − 𝐶𝑥 and 𝑏 ∈ 𝑁(𝑦) − 𝐶𝑦 , then 𝑎𝑏 is the next parallel edge of 𝑥𝑦.
Moreover, 𝑥𝑦 and 𝑎𝑏 have the same middle.
     Theorem 6.19: If 𝑇 is a tree and 𝑢𝑣 is the next parallel edge of 𝑥𝑦 in 𝑇𝑥𝑦      𝑘
                                                                                       with
                                                𝑦
𝑥𝑢, 𝑦𝑣 ∈ 𝐸(𝑇) , then    𝑢
                       𝑢𝑣 𝑤1 = 𝑛𝑇𝑥 (𝑢),  𝑣
                                        𝑢𝑣𝑤1 = 𝑛𝑇 (𝑣) and:
                                                89


                                                                                𝑘′
        𝑘+2 )         𝑘                                                              𝑢       𝑦       𝑥       𝑣
   𝑊′(𝑇𝑢𝑣     − 𝑊′(𝑇𝑥𝑦  ) = −2       ∑          𝑤𝑖𝑗 +         ∑       𝑤𝑖𝑗 + 2 ∑( 𝑢𝑣    𝑤1 . 𝑥𝑦𝑤𝑟 + 𝑥𝑦  𝑤𝑟 . 𝑢𝑣 𝑤1 )
                                  𝑖+𝑗 ≤ 𝑘 ′ +1            𝑖+𝑗=𝑘 ′ +1           𝑟=1
                                  𝑢        𝑦             𝑥         𝑣             𝑢       𝑣
                             −( 𝑢𝑣  𝑤1 . 𝑥𝑦𝑤𝑘 ′     +   𝑥𝑦𝑤𝑘 ′ . 𝑢𝑣𝑤1 )  +  −4 𝑢𝑣  𝑤1 . 𝑢𝑣 𝑤1 ,          𝑘 𝑖𝑠 𝑜𝑑𝑑,
                                                                                  𝑘′
       𝑘+2 )        𝑘                                                                  𝑢       𝑦       𝑥       𝑣
  𝑊′(𝑇𝑢𝑣     − 𝑊′(𝑇𝑥𝑦 ) = −2        ∑         𝑤𝑖𝑗 + 2          ∑       𝑤𝑖𝑗 + 2. ∑( 𝑢𝑣    𝑤1 . 𝑥𝑦𝑤𝑟 + 𝑥𝑦  𝑤𝑟 . 𝑢𝑣 𝑤1 )
                                𝑖+𝑗 ≤ 𝑘 ′ +1               𝑖+𝑗= 𝑘 ′ +1           𝑟=1
                                  𝑢        𝑦             𝑥         𝑣           𝑢      𝑣
{                          −2( 𝑢𝑣   𝑤1 . 𝑥𝑦𝑤𝑘 ′     +   𝑥𝑦𝑤𝑘 ′ . 𝑢𝑣𝑤1 )  −  4 𝑢𝑣𝑤1 . 𝑢𝑣 𝑤1 ,          𝑘 𝑖𝑠 𝑒𝑣𝑒𝑛.
                           𝑦
where the vectors  𝑥𝑦𝑾, 𝑥𝑦𝑾
                    𝑥
                                 and the matrix             𝑥𝑦𝑾    = [𝑤𝑖𝑗 ] are associated with 𝑇𝑥𝑦     𝑘
                                                                                                          .
    Proof: Suppose we have 𝑇𝑥𝑦      𝑘
                                        and 𝑥 and 𝑦 are some non-leaf vertices. Then, 𝑢𝑣 with
𝑢 ∈ 𝑁(𝑥) − 𝐶𝑥 and 𝑣 ∈ 𝑁(𝑦) − 𝐶𝑦 is the next parallel edge of 𝑥𝑦. With the theorems’
assumptions, if we remove 𝑥𝑦 from 𝑇𝑥𝑦          𝑘
                                                   and add 𝑢𝑣 to 𝑇,
                                            𝑛𝑇𝑥 (𝑢)              0
                                               𝑥              𝑛𝑇𝑥 (𝑢)
                                             𝑥𝑦𝑤1
                                               𝑥                 0
                                             𝑥𝑦𝑤2
                                𝑢                                0
                               𝑢𝑣𝑾    =                 −                                                    (6.24)
                                                 ⋮
                                              𝑥                   ⋮
                                           [ 𝑥𝑦  𝑤𝑘 ′ ]      [ 0 ]
    And
                                                𝑦                 0
                                              𝑛𝑇 (𝑣)             𝑦
                                                𝑦              𝑛𝑇 (𝑣)
                                               𝑥𝑦𝑤1
                                                𝑦                 0
                              𝑣                𝑥𝑦𝑤2               0
                           ( 𝑢𝑣 𝑾 )𝑇   =                 −                                                   (6.25)
                                                  ⋮                ⋮
                                               𝑦
                                            [ 𝑥𝑦𝑤𝑘 ′ ]        [ 0 ]
                                                             𝑦
    That means,    𝑢
                  𝑢𝑣𝑤1   = 𝑛𝑇𝑥 (𝑢) and         𝑣
                                              𝑢𝑣𝑤1    = 𝑛𝑇 (𝑣). We know that             𝑢𝑣𝑾    =  𝑢
                                                                                                  𝑢𝑣𝑾
                                                                                                             𝑣
                                                                                                        × ( 𝑢𝑣 𝑾)𝑡 .
Expanding the following equation, using equations 6.24, 6.25, and lemma 6.2:
                                                           90


                            𝑘+2 )            𝑘
                      𝑊′(𝑇𝑢𝑣      − 𝑊′(𝑇𝑥𝑦       ) = ‖𝑭𝑘+2 ⊚ 𝑢𝑣𝑾‖ − ‖𝑭𝑘 ⊚ 𝑥𝑦𝑾‖,
     we have,
                                                                              𝑘′
          𝑘+2 )        𝑘                                                           𝑢        𝑦      𝑥       𝑣
    𝑊′(𝑇𝑢𝑣      − 𝑊′(𝑇𝑥𝑦 ) = −2      ∑         𝑤𝑖𝑗 +       ∑        𝑤𝑖𝑗 + 2 ∑( 𝑢𝑣     𝑤1 . 𝑥𝑦𝑤𝑟 + 𝑥𝑦 𝑤𝑟 . 𝑢𝑣 𝑤1 )
                                  𝑖+𝑗 ≤ 𝑘 ′ +1          𝑖+𝑗=𝑘 ′ +1           𝑟=1
                                  𝑢        𝑦           𝑥        𝑣              𝑢        𝑣
                             −( 𝑢𝑣  𝑤1 . 𝑥𝑦𝑤𝑘 ′    +  𝑥𝑦𝑤𝑘 ′ . 𝑢𝑣𝑤1 )  +  −4 𝑢𝑣   𝑤1 . 𝑢𝑣 𝑤1 ,         𝑘 𝑖𝑠 𝑜𝑑𝑑,
                                                                                𝑘′
         𝑘+2 )       𝑘                                                                𝑢       𝑦      𝑥       𝑣
  𝑊′(𝑇𝑢𝑣       − 𝑊′(𝑇𝑥𝑦 ) = −2      ∑        𝑤𝑖𝑗 + 2        ∑        𝑤𝑖𝑗 + 2. ∑( 𝑢𝑣     𝑤1 . 𝑥𝑦𝑤𝑟 + 𝑥𝑦 𝑤𝑟 . 𝑢𝑣 𝑤1 )
                                𝑖+𝑗 ≤ 𝑘 ′ +1             𝑖+𝑗= 𝑘 ′ +1           𝑟=1
                                  𝑢        𝑦           𝑥        𝑣            𝑢      𝑣
{                           −2( 𝑢𝑣  𝑤1 . 𝑥𝑦𝑤𝑘 ′    +  𝑥𝑦𝑤𝑘 ′ . 𝑢𝑣𝑤1 )  −  4 𝑢𝑣𝑤1 . 𝑢𝑣  𝑤1 ,         𝑘 𝑖𝑠 𝑒𝑣𝑒𝑛.
     This completes the proof.                                                                                   ■
     6.3.2 A Matrix Norm Technique
     In general, the time complexity of calculating 𝑊 ′ (𝑇𝑥𝑦            𝑘
                                                                          ) = ‖𝐹𝑘 ⊚ 𝑥𝑦𝑾‖ is 𝑂(𝑘 2 )-time.
Here, using some regularity of 𝐹𝑘 ⊚ 𝑥𝑦𝑾, a technique is proposed that reduces the total
time complexity of computing, {𝑊 ′ (𝑇𝑥𝑦        𝑘
                                                  )} 𝑥𝑦∈𝐸(𝑇 𝑐) . But note that,
      I-Using theorem 6.19, it is impossible to calculate 𝑊′(𝑇𝑥𝑦                𝑘
                                                                                  ) in less than 𝑂(𝑘 2 ) for a
single given 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ).
     II-But, if 𝑢𝑣 is the next parallel edge of 𝑥𝑦, then we will achieve 𝑊 ′ (𝑇𝑢𝑣                     𝑘+2 )
                                                                                                             from
𝑊 ′ (𝑇𝑥𝑦
       𝑘
         ) in 𝑂(𝑘).
     If 𝐴 is a given matrix, let 𝐴[specified indices] denote a matrix corresponding to 𝐴
where the specified indices have the same values as 𝐴 and are zero otherwise. Also, [𝑎 ∧ 𝑉]
notation appends the number 𝑎 as the first entry of a vector 𝑉, extending its length by
one.
                                                         91


    Proposition 6.20: Suppose we have 𝑇𝑥𝑦          𝑘
                                                     , and 𝑎𝑏 is the next parallel edge of 𝑥𝑦. If
we have
                                         𝑦
                           𝑥𝑦𝑾, 𝑥𝑦𝑾, 𝑥𝑦𝑾,                ), and ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖,
                                  𝑥
                                               𝑊 ′ (𝑇𝑥𝑦𝑘
                          𝑦
then using 𝑛𝑇𝑥 (𝑎) and 𝑛𝑇 (𝑏) we can obtain the following in 𝑂(𝑘) = 𝑂(𝑑(𝑎, 𝑏))-time.
                                𝑎      𝑏             𝑘+2
                         𝑎𝑏 𝑾, 𝑎𝑏 𝑾, 𝑎𝑏 𝑾,   𝑊 ′ (𝑇𝑎𝑏     ) and ‖𝑶𝑘+2 ⊚ 𝑎𝑏𝑾‖.
    Proof: Suppose we have 𝑇𝑥𝑦     𝑘
                                     and 𝑎𝑏 is the next parallel edge of 𝑥𝑦 and, 𝑛𝑇𝑥 (𝑎) and
 𝑦
𝑛𝑇 (𝑏) are given. Thus,
                                 𝑎 ∈ 𝑁(𝑥) − 𝐶𝑥 and 𝑏 ∈ 𝑁(𝑦) − 𝐶𝑦 .
                                                             𝑦
    We want to prove that if we have         𝑥𝑦𝑾, 𝑥𝑦𝑾, 𝑥𝑦𝑾,
                                                      𝑥
                                                                  𝑊 ′ (𝑇𝑥𝑦𝑘
                                                                            ) and ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ then
                       𝑎      𝑏            𝑘+2
we can obtain   𝑎𝑏 𝑾, 𝑎𝑏 𝑾, 𝑎𝑏 𝑾,   𝑊 ′ (𝑇𝑎𝑏   ) and ‖𝑶𝑘+2 ⊚ 𝑎𝑏𝑾‖ with 𝑂(𝑘) operations. We
break the proof into four parts, 𝑨), 𝑩), 𝑪), and 𝑫), as follows:
𝑨) ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ → ‖𝑶𝑘+2 ⊚ 𝑎𝑏𝑾‖
    By definition of  𝑎𝑏 𝑾,  one can see that:
    If 𝑘 ≠ 1,
‖𝑶𝑘+2 ⊚ 𝑎𝑏𝑾‖
                                                                            𝑦             𝑦
               = ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ − ‖ 𝑥𝑦𝑾[𝑖 + 𝑗 = 𝑘 ′ + 1]‖ + 𝑛𝑇𝑥 (𝑎). 𝑥𝑦𝑾[𝑘 ′ ] + 𝑛𝑇 (𝑏). 𝑥𝑦       𝑥
                                                                                                𝑾[𝑘 ′ ]
    And if 𝑘 = 1,
                                         𝑦              𝑦
            ‖𝑶𝑘+2 ⊚ 𝑎𝑏𝑾‖ = 𝑛𝑇𝑥 (𝑎). 𝑥𝑦     𝑾[𝑘 ′ ] + 𝑛𝑇 (𝑏). 𝑥𝑦𝑥
                                                                 𝑾[𝑘 ′ ] − 3𝑛𝑇𝑥 (𝑎). 𝑛𝑇𝑥 (𝑎).
    As ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ is given, ‖𝑶𝑘+2 ⊚ 𝑎𝑏𝑾‖ is calculatable in 𝑂(𝑘)-time clearly.
                                                    92


                         𝑘+2
𝑩) 𝑊 ′ (𝑇𝑥𝑦𝑘
             ) → 𝑊 ′ (𝑇𝑎𝑏      )
    Using theorem 6.19 and our notation, one can check that,
    1-If 𝑘 is Even
           𝑘+2                                                                                      𝑦
    𝑊 ′ (𝑇𝑎𝑏   ) = 𝑊 ′ (𝑇𝑥𝑦  𝑘
                                ) + 2‖ 𝑥𝑦𝑾[𝑖 + 𝑗 = 𝑘 ′ + 1]‖ − 2‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ + 2‖𝑛𝑇𝑥 (𝑎). 𝑥𝑦𝑾‖
                       𝑦                         𝑦               𝑦
               +2‖𝑛𝑇 (𝑏). 𝑥𝑦𝑥𝑾‖ − 2𝑛𝑇𝑥 (𝑎). 𝑥𝑦𝑾[𝑘 ′ ] − 2𝑛𝑇 (𝑏). 𝑥𝑦     𝑥
                                                                          𝑾[𝑘 ′ ] − 4 𝑛𝑇𝑥 (𝑎). 𝑛𝑇𝑥 (𝑎).
    2-If 𝑘 is Odd and 𝑘 ≥ 3
           𝑘+2                                                                                    𝑦
   𝑊 ′ (𝑇𝑎𝑏    ) = 𝑊 ′ (𝑇𝑥𝑦  𝑘
                                ) + ‖ 𝑥𝑦𝑾[𝑖 + 𝑗 = 𝑘 ′ + 1]‖ − 2‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ + 2‖𝑛𝑇𝑥 (𝑎). 𝑥𝑦𝑾‖
                               𝑦                      𝑦             𝑦
                     + 2‖𝑛𝑇 (𝑏). 𝑥𝑦𝑥𝑾‖ − 𝑛𝑇𝑥 (𝑎). 𝑥𝑦𝑾[𝑘 ′ ] − 𝑛𝑇 (𝑏). 𝑥𝑦    𝑥
                                                                              𝑾[𝑘 ′ ] − 4 𝑛𝑇𝑥 (𝑎). 𝑛𝑇𝑥 (𝑎)
    And if 𝑘 = 1
                         𝑘+2                  𝑦          𝑦
                   𝑊 ′ (𝑇𝑎𝑏    ) = ‖𝑛𝑇𝑥 (𝑎). 𝑥𝑦𝑾‖ + ‖𝑛𝑇 (𝑏). 𝑥𝑦𝑥𝑾‖ − 3𝑛𝑇𝑥 (𝑎). 𝑛𝑇𝑥 (𝑎)
    At the RHS of all the above cases, except for ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ and 𝑊 ′ (𝑇𝑥𝑦                   𝑘
                                                                                              ) that is given
by the assumptions, everything else can be calculated in 𝑂(𝑘).
                    𝑎              𝑦       𝑏
    𝑪) 𝑥𝑦𝑥
           𝑾⟶      𝑎𝑏𝑾    and     𝑥𝑦𝑾   ⟶ 𝑎𝑏𝑾
                                           𝑎           𝑏
    By equations 6.24 and 6.25,           𝑎𝑏𝑾   and   𝑎𝑏 𝑾    are computable in 𝑂(1) using           𝑥
                                                                                                    𝑥𝑦𝑾   and
 𝑦
𝑥𝑦𝑾,  respectively. That’s because,
                                                                                𝑦
                                 𝑛𝑇𝑥 (𝑎)                                     𝑛𝑇 (𝑏)
                            𝑥          𝑥                                  𝑦         𝑥
                           𝑥𝑦𝑤1 − 𝑛 𝑇 (𝑎)                               𝑥𝑦𝑤1 − 𝑛 𝑇 (𝑏)
                                   𝑥                                           𝑥
                                  𝑥𝑦𝑤2                                        𝑥𝑦𝑤2
                 𝑎                                           𝑏
                𝑎𝑏𝑾   =                         and       ( 𝑎𝑏 𝑾)𝑇 =                      .
                                     ⋮                                            ⋮
                                  𝑥                                            𝑦
                         [       𝑥𝑦𝑤𝑘 ′   ]                           [       𝑥𝑦𝑤𝑘 ′    ]
                                                       93


     𝑫)  𝑥𝑦𝑾   ⟶   𝑎𝑏 𝑾
     Using equations 6.24 and 6.25, and the definition of         𝑎𝑏 𝑾, one can see that line 6 in
the following outputs 𝑎𝑏𝑾.
       Let  𝑎𝑏 𝑾   = 0(𝑘′+1)×(𝑘′+1)
                                             𝑦         𝑦
       𝟏 − 𝑎𝑏𝑾[𝑓𝑖𝑟𝑠𝑡 𝑟𝑜𝑤]+= 𝑛𝑇𝑥 (𝑎). [𝑛𝑇 (𝑏) ∧ 𝑥𝑦𝑾]
                                         𝑦
       𝟐 − 𝑎𝑏𝑾[𝑓𝑖𝑟𝑠𝑡 𝑐𝑜𝑙𝑢𝑚𝑛]+= 𝑛𝑇 (𝑏). [𝑛𝑇𝑥 (𝑎) ∧ 𝑥𝑦𝑥𝑾]
                                                𝑦        𝑦
       𝟑 − 𝑎𝑏𝑾[𝑠𝑒𝑐𝑜𝑛𝑑 𝑟𝑜𝑤]−= 𝑛𝑇𝑥 (𝑎). [𝑛𝑇 (𝑏) ∧ 𝑥𝑦𝑾]
                                           𝑦
       𝟒−   𝑎𝑏𝑾[𝑠𝑒𝑐𝑜𝑛𝑑      𝑐𝑜𝑙𝑢𝑚𝑛]−= 𝑛𝑇 (𝑏). [𝑛𝑇𝑥 (𝑎) ∧ 𝑥𝑦𝑥𝑾]
                                      𝑦
       𝟓 − 𝑎𝑏𝑾[2][2]+= 𝑛𝑇𝑥 (𝑎). 𝑛𝑇 (𝑏)
       𝟔 − 𝑎𝑏𝑾[2: 𝑘, 2: 𝑘] =    𝑥𝑦𝑾
     Any of the above lines can be reached in 𝑂(𝑘) except            𝑥𝑦𝑾 in line 6, which is given
by the assumptions. This completes the proof.                                                    ■
     6.3.3 Main Algorithm for Inset Edge of Trees
     In this section, based on 𝑨), 𝑩), 𝑪) and 𝑫) from proposition 6.20, we devise a recursive
algorithm for computing {𝑊 ′ (𝑇𝑥𝑦   𝑘
                                       )} 𝑥𝑦∈𝐸(𝑇 𝑐) of a given tree 𝑇.
     Remark 6.20.5: Suppose 𝑇 is a tree, and we have, {(𝑛𝑣𝑇 (𝑢), 𝑛𝑢𝑇 (𝑣))}𝑢𝑣∈𝐸(𝑇)
     1) If 𝑣 ∈ 𝑉(𝑇) and 𝑥, 𝑦 ∈ 𝑁(𝑣), then using lemma 6.2 and definitions
 𝑥
𝑥𝑦𝑾   = [𝑛𝑣𝑇 (𝑥)]
 𝑦
𝑥𝑦𝑾   = [𝑛𝑣𝑇 (𝑦)]
𝑥𝑦𝑾   = [𝑛𝑣𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)]
‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ = 𝑛𝑣𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)
𝑊 ′ (𝑇𝑥𝑦
      𝑘
         ) = 𝑛𝑣𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)
                                                     94


     By proposition 6.20, we can compute the above equivalent data for the next parallel
edges of 𝑥𝑦 and so on. Thus, starting from every {𝑥, 𝑦} ⊆ 𝑁(𝑣) and producing the data
for the next parallel edges, we will compute, 𝑊 ′ for all the edges with the middle, 𝑣. ▲
     2) If 𝑢𝑣 ∈ 𝐸(𝑇) and 𝑥𝑦 is the next parallel edge of 𝑢𝑣. By lemma 6.2 and definitions
 𝑥              𝑛𝑢𝑇 (𝑥)
𝑥𝑦𝑾   =[                     ]
          𝑛𝑣𝑇 (𝑢) − 𝑛𝑢𝑇 (𝑥)
 𝑦              𝑛𝑣𝑇 (𝑦)
𝑥𝑦𝑾   =[   𝑢 (𝑣)             ]
          𝑛𝑇       − 𝑛𝑣𝑇 (𝑦)
                𝑛𝑢𝑇 (𝑥)
𝑥𝑦𝑾 = [                      ] . [𝑛𝑣𝑇 (𝑦) 𝑛𝑢𝑇 (𝑣) − 𝑛𝑣𝑇 (𝑦)]
          𝑛𝑣𝑇 (𝑢) − 𝑛𝑢𝑇 (𝑥)
‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ = 𝑛𝑢𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)
𝑊 ′ (𝑇𝑥𝑦
      𝑘
         ) = 2. 𝑛𝑢𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)
     Similar to 1) and using proposition 6.20, we can compute the above equivalent data
for the next parallel edges of 𝑥𝑦 and so on. That helps to compute 𝑊 ′ for all the edges
with the middle 𝑢𝑣.                                                                          ▲
     By theorem 6.17, iterating the idea of 1) for the vertices of 𝑇 and 2) for the edges of
𝑇, we compute {𝑊 ′ (𝑇𝑥𝑦      𝑘
                                 )} 𝑥𝑦∈𝐸(𝑇 𝑐) . We will implement the mentioned method with the
following algorithm. Its correctness follows the passed results’ proof.
     Algorithm 6.21:
     Input: Adjacency list of an 𝑛-vertex nontrivial tree 𝑇
     Output: {𝑾′(𝑻𝒌𝒙𝒚 )}𝒙𝒚∈𝑬(𝑻𝒄)
     Compute 𝑁 = {(𝑛𝑣𝑇 (𝑢), 𝑛𝑢𝑇 (𝑣))}𝑢𝑣∈𝐸(𝑇)
                                                         95


𝐅𝐨𝐫 𝑣 ∈ 𝑉(𝑇):
     𝐅𝐨𝐫 𝑥 ∈ 𝑁(𝑣)
         𝐅𝐨𝐫 𝑦 ∈ 𝑁(𝑣)
           𝐢𝐟 (𝑥 ≠ 𝑦)
              𝑥𝑦𝑾   = [𝑛𝑣𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)]
               𝐴 = 𝑁(𝑥) − 𝑣
               𝐵 = 𝑁(𝑦) − 𝑣
              𝑥
             𝑥𝑦𝑾   = [𝑛𝑣𝑇 (𝑥)]
              𝑦
             𝑥𝑦𝑾   = [𝑛𝑣𝑇 (𝑦)]
             ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ = 𝑛𝑣𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)
             𝑊 ′ (𝑇𝑥𝑦
                   𝑘
                      ) = 𝑛𝑣𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)
             𝐎𝐮𝐭𝐩𝐮𝐭 𝑊 ′ (𝑇𝑥𝑦 𝑘
                               ) and 𝑎𝑏
                                              𝑦
            𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧( 𝑥𝑦𝑾, ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖, 𝑥𝑦𝑥𝑾, 𝑥𝑦𝑾, 𝑊 ′ (𝑇𝑥𝑦
                                                        𝑘
                                                           ), 𝐴, 𝐵, 𝑥, 𝑦, 𝑘 ′ = 1, 𝑝 = 1)
           𝐞𝐧𝐝
         𝐞𝐧𝐝
      𝐞𝐧𝐝
𝐞𝐧𝐝
                                           96


𝐅𝐨𝐫 𝑢𝑣 ∈ 𝐸(𝑇):
      𝐅𝐨𝐫 𝑥 ∈ 𝑁(𝑢) − 𝑣
        𝐅𝐨𝐫 𝑦 ∈ 𝑁(𝑣) − 𝑢
                           𝑛𝑢𝑇 (𝑥)
           𝑥𝑦𝑾 = [ 𝑣                   ] . [𝑛𝑣𝑇 (𝑦) 𝑛𝑢𝑇 (𝑣) − 𝑛𝑣𝑇 (𝑦)]
                     𝑛𝑇 (𝑢) − 𝑛𝑢𝑇 (𝑥)
           𝐴 = 𝑁(𝑥) − 𝑢
           𝐵 = 𝑁(𝑦) − 𝑣
           𝑥              𝑛𝑢𝑇 (𝑥)
          𝑥𝑦𝑾   =[                    ]
                    𝑛𝑣𝑇 (𝑢) − 𝑛𝑢𝑇 (𝑥)
            𝑦              𝑛𝑣𝑇 (𝑦)
           𝑥𝑦𝑾   =[                    ]
                     𝑛𝑢𝑇 (𝑣) − 𝑛𝑣𝑇 (𝑦)
            ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖ = 𝑛𝑢𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)
            𝑊 ′ (𝑇𝑥𝑦
                  𝑘
                     ) = 2. 𝑛𝑢𝑇 (𝑥). 𝑛𝑣𝑇 (𝑦)
            𝐎𝐮𝐭𝐩𝐮𝐭 𝑊 ′ (𝑇𝑥𝑦   𝑘
                                ) and 𝑎𝑏
                                                         𝑦
           𝑭𝒖𝒏𝒄𝒕𝒊𝒐𝒏( 𝑥𝑦𝑾, ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖, 𝑥𝑦𝑥𝑾, 𝑥𝑦𝑾, 𝑊 ′ (𝑇𝑥𝑦           𝑘
                                                                      ), 𝐴, 𝐵, 𝑥, 𝑦, 𝑘 ′ = 1, 𝑝 = 2)
        𝐞𝐧𝐝
      𝐞𝐧𝐝
 𝐞𝐧𝐝
                                                    97


                                        𝑦
𝑭𝒖𝒏𝒄𝒕𝒊𝒐𝒏( 𝑥𝑦𝑾, ‖𝑶𝑘 ⊚ 𝑥𝑦𝑾‖, 𝑥𝑦𝑥𝑾, 𝑥𝑦𝑾, 𝑊 ′ (𝑇𝑥𝑦  𝑘
                                                  ), 𝐴, 𝐵, 𝑥, 𝑦, 𝑘 ′ , 𝑝)
𝐢𝐟 (𝐴 ≠ ∅ 𝑎𝑛𝑑 𝐵 ≠ ∅)
      𝐅𝐨𝐫 𝑎 ∈ 𝐴
       𝐅𝐨𝐫 𝑏 ∈ 𝐵
            𝐴 = 𝑁(𝑎) − 𝑥
            𝐵 = 𝑁(𝑏) − 𝑦
            Compute ‖𝑶𝑘+2 ⊚ 𝑎𝑏𝑾‖              \\based on 𝑨) proposition 6.20 and N
                               𝑘+2
            Compute 𝑊 ′ (𝑇𝑎𝑏       )          \\based on 𝑩) proposition 6.20 and N
                         𝑎           𝑏
            Compute     𝑎𝑏 𝑾  and   𝑎𝑏 𝑾      \\based on 𝑪) proposition 6.20 and N
            Compute    𝑎𝑏 𝑾                   \\based on 𝑫) proposition 6.20 and N
                                 𝑘+2
            𝐎𝐮𝐭𝐩𝐮𝐭        𝑊 ′ (𝑇𝑎𝑏   ) and 𝑎𝑏
            𝑭𝒖𝒏𝒄𝒕𝒊𝒐𝒏( 𝑎𝑏𝑾, ‖𝑶𝑘+2 ⊚ 𝑎𝑏𝑾‖, 𝑎𝑏𝑎𝑾, 𝑎𝑏𝑏𝑾, 𝑊 ′ (𝑇𝑎𝑏     𝑘+2
                                                                        ), 𝐴, 𝐵, 𝑎, 𝑏, 𝑘 ′ + 1, 𝑝)
         𝐞𝐧𝐝
       𝐞𝐧𝐝
    𝐞𝐧𝐝                                                                                                  ■
     6.3.4 Algorithm Complexity and Conclusion
     By theorem 6.17, each vertex/edge is the middle of an equivalence class of inset edge.
Algorithm 6.21 iterates over the vertices and edges of a tree as middles, computing 𝑊′ for
each element of each class of inset edges regarding each middle using proposition 6.20. By
theorem 6.17, the equivalence classes of middles partition the set of the trees’ inset edges.
Therefore, the algorithm uniquely covers all inset edges, computing {𝑊 ′ (𝑇𝑥𝑦          𝑘
                                                                                          )} 𝑥𝑦∈𝐸(𝑇 𝑐) .
                                               98


     Lemma 6.22: Suppose 𝑇 is a tree, and 𝑣 ∈ 𝑉(𝐺) or 𝑒 ∈ 𝐸(𝐺) is the middle of the
inset edge, 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ), with 𝑑(𝑥, 𝑣 or 𝑒) = 𝑑(𝑦, 𝑣 or 𝑒) = 𝑘. Then algorithm 6.21 computes
𝑊′(𝑇𝑥𝑦𝑘
        ), in 𝑂(𝑘) = 𝑂(𝑑(𝑥, 𝑦))-time.
     Proof: Use remark 6.20.5 and proposition 6.20.                                                       ■
     Lemma 6.23(see [9,16]): If 𝑇 is a tree on 𝑛 vertices, then
                                            (𝑛 − 1)2 ≤ 𝑊(𝑇 ) ≤ (𝑛+1     3
                                                                          )                               ■
     The Wiener index of the molecules’ chemical graphs is correlated with the molecules’
specific physical and chemical properties. There are several efficient algorithms for
calculating the Wiener index and its variations for a graph [1,7,11,13]. By theorm 3., one
can calculate 𝑊(𝑇) in 𝑂(𝑛)-time, where 𝑛 = |𝑉(𝑇)|. The next theorem gives a reflctive
relation between the complexity of computing 𝑊′(𝑇𝑥𝑦 ) for all 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ) and 𝑊(𝑇).
     Theorem 6.24: Suppose 𝑇 is a tree. Algorithm 6.21’s time complexity for computing
{𝑊′(𝑇𝑥𝑦 )}𝑥𝑦∈𝐸(𝑇 𝑐) is 𝑂(𝑊(𝑇))-time.
     Proof: Suppose 𝑇 is an 𝑛-vertex tree and 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ) is an inset edge. According to
lemma 6.22, algorithm 6.21 requires, at most 𝑐1 𝑑 𝑇 (𝑥, 𝑦) + 𝑐2 operations to compute,
𝑊 ′ (𝑇𝑥𝑦
      𝑘
         ), for some 𝑐1, 𝑐2 > 0. Thus by lemma 6.23, algorithm 6.21s’ total operations for the
computing {𝑊′(𝑇𝑥𝑦    𝑘
                         )}𝑥𝑦∈𝐸(𝑇 𝑐) is bounded by the following, where 𝑐3 ,𝑐4 , and 𝑐5 are some
positive constants.
                                                                                𝑛
           ∑            (𝑐1 𝑑 𝑇 (𝑥, 𝑦) + 𝑐2 ) ≤ 𝑐3 ∑            𝑑 𝑇 (𝑥, 𝑦) + (( ) − (𝑛 − 1)) 𝑐4
              𝑥𝑦∈𝐸(𝑇 𝑐 )                             𝑥𝑦∈𝐸(𝑇 𝑐 )                 2
                                                       𝑛
                                       = 𝑐3 𝑊(𝑇) + (( ) − (𝑛 − 1)) 𝑐4 − 𝑐3 (𝑛 − 1) < 𝑐5 𝑊(𝑇).
                                                       2
     That completes the proof.                                                                            ■
     Remark 6.25: By theorem 6.24, computing {𝑊′(𝑇𝑥𝑦                  𝑘
                                                                         )}𝑥𝑦∈𝐸(𝑇 𝑐) takes 𝑂(𝑊(𝑇))-time.
                                                                                             𝑛2 −3𝑛+2
By [15], 𝑊(𝑇) ≈ (𝑛2) log 𝑛, on average. Due to the presence of 𝑖 = |𝐸(𝑇 𝑐 )| =                        inset
                                                                                                 2
                                                      99


edges, we can sort {𝑊′(𝑇𝑥𝑦𝑘
                            )}𝑥𝑦∈𝐸(𝑇 𝑐) in 𝑂(𝑖. log(𝑛))-time. And it is surprising that, we can
compute all elements of {𝑊′(𝑇𝑥𝑦  𝑘
                                   )}𝑥𝑦∈𝐸(𝑇 𝑐) and then sort it, all in just 𝑂(𝑖. log (𝑛))-time on
average.
     We will have 𝑊(𝑇𝑥𝑦 𝑘
                          ), once we have 𝑊(𝑇) and 𝑊 ′ (𝑇𝑥𝑦     𝑘
                                                                  ), because 𝑊 ′ (𝑇𝑥𝑦 ) − 𝑊(𝑇) =
𝑊(𝑇𝑥𝑦 ). Thus, the Wiener index of a unicyclic graph is computed in 𝑂(log 𝑛)-time on
average and 𝑂(1)-time at best by algorithm 6.21. Using general tools such as distance
matrix, one achieves {𝑊′(𝐺𝑥𝑦 )}𝑥𝑦∈𝐸(𝐺𝑐) in 𝑂(𝑛3 |𝐸(𝐺 𝑐 )|) time. That gives an 𝑂(𝑛5 )-time
complexity when 𝐺 is a tree [20].                                                                 ▲
     The main algorithms is implemented on the pg platform by professor Esfahanian. See
appendix D.
     Remark 6.26: We saw that 𝑊 ′ (𝑇𝑢𝑣     3 )
                                               = 𝑤𝑢 . 𝑤𝑣 . We guess that computing 𝑊′(𝑇𝑥𝑦    𝑘
                                                                                               ) for
any 𝑥𝑦 ∈ 𝐸(𝑇 𝑐 ) can be done in 𝑂(1)-time, which is now 𝑂(𝑑(𝑥, 𝑦)) by algorithm 6.21. We
will probably need more matrix techniques to achieve such a time complexity. Moreover,
if we only want to find the minimum of 𝑊′, we can limit the search space based on the
middles. Thus, based on our intuition, we have the following conjectures:
     Conjecture 6.27: {𝑊(𝑇𝑥𝑦   𝑘
                                  )}𝑥𝑦∈𝐸(𝑇 𝑐) can be calculated in 𝑂(|𝐸(𝑇 𝑐 )|)-time.             ▲
     Conjecture 6.28: For a given tree, 𝑇, the middle(s) of the inset edge(s) with the
minimum 𝑊 ′ belong(s) to 𝐸(𝑃′ ) ∪ 𝑉(𝑃′ ) with 𝑃′ is the longest path(s) between the
center(s) and 𝜎𝑇 -Root(s) of 𝑇.                                                                   ▲
                                                 100


                                          REFERENCES
[1] Roberto Aringhieri, Pierre Hansen, Federico Malucelli, A Linear Algorithm for the Hyper-
     Wiener Index of Chemical Trees, J. Chem. Inf. Comput. Sci., 41 (2001), 958-963.
[2] F. Chung, L. Lu, The Average Distances in Random Graphs with Given Expected Degrees,
     Proceedings of the National Academy of Sciences, 99 (2002), 15879-15882.
[3] A. Clauset, C. Moore, M. E. J. Newman, Hierarchical Structure and the Prediction of
     Missing Links in Networks, Nature, 453 (2008), 98-101.
[4] J. Copic, M. O. Jackson, A. Kirman, Identifying Community Structures from Network Data
     via Maximum Likelihood Methods, The B.E. Journal of Theoretical Economics, 9 (2005),
     09-27.
[5] S. Currarini, M. O. Jackson, P. Pin, An Economic Model of Friendship: Homophily,
     Minorities and Segregation, Econometrica, 77 (2009), 1003-1045.
[6] A. Drger, M. Kronfeld, M. J. Ziller, J. Supper, H. Planatscher, J.B. Magnus, M. Oldiges, O.
     Kohlbacher, A. Zell, Modeling metabolic networks in C. glutamicum: a comparison of rate
     laws in combination with various parameter optimization strategies", BMC Syst. Biol., 3
     (2009).
[7] M.H. Khalifeh, Abdol-Hossein Esfahanian, Some results about the inset edge and average
     distance of trees, Discrete Appl. Math., 325 (2023), 186-199.
[8] Aleksander Kelenc, Sandi Klavžar, Niko Tratnik, The Edge-Wiener Index of Benzenoid
     Systems in Linear Time, MATCH Commun. Math. Comput. Chem., 74 (2015), 521-532.
[9] M.H. Khalifeh, H.Yousefi Azari, A.R. Ashrafi, S.G. Wagner, Some new results on distance-
     based graph invariants, Eur. J. Comb., 30 (2009), 1149-1163.
[10] Sandi Klavzar, Ivan Gutman, Wiener number of vertex-weighted and a chemical
     application, Discrete Appl. Math., 80 (1997), 73-81.
[11] Sandi Klavžar, Petra Žigert, Ivan Gutman, An algorithm for the calculation of the hyper-
     Wiener index of benzenoid hydrocarbons, Computers & Chemistry, 24 (2000), 229-233.
[12] Y. Matsuo, Y. Ohsawa, M. Ishizuka, Average-Clicks: A New Measure of Distance on the
     World Wide Web, Journal of Intelligent Information Systems, 20 (2003), 20-51.
[13] Bojan Mohar, Tomaž Pisanski, How To Compute The Winer Index of a Graph, J. of
                                                101


     Mathematical Chem., 267 (1988), 277 267.
[14] A. Meyerson, B. Tagiku, Minimizing Average Shortest Path Distances via Shortcut Edge
     Addition, Approximation, randomization, and combinatorial optimization, Algorithms and
     techniques. 12th international workshop, APPROX 2009, and 13th international
     workshop, RANDOM 2009, Berkeley, CA, USA, August 2123, (2009), Proceedings
     (pp.272-285)
[15] Z. Shen, The average diameter of general tree structures, Comput. Math. Appl., 36 (1998),
     111-130.
[16] H. B. Valikara, V. S. Shigehali, H. S. Ramane, Bounds on the Wiener number of a graph,
     MATCH Commun. Math. Comput. Chem, 50 (2004), 117-132.
[17] Stephan G. Wagner, A Class of Trees and its Wiener Index, Acta Applicandae
     Mathematica, 91 (2006), 119-132.
[18] H. Wiener, Structural determination of the paraffin boiling points, J. Am. Chem. Soc., 69
     (1947), 17-20.
[19] A. R. Ashrafi, S. Yousefi, A new algorithm for computing distance matrix and Wiener
     index of zig-zag polyhex nanotubes, Nanoscale Research Letters, 2 (2007), 202-206.
[20] Dennis Ross, Edge impact in graphs and social network matrix completion, Diss. Michigan
     State University, (2014).
                                                102


                     APPENDIX A: EQUATIONS 6-10 TO 6-12
                                           𝑦                                    𝑛−𝑘+2    𝑛−𝑘+2
     We have   𝑥
              𝑥𝑦𝑾 = [𝑤𝑥 , 1,1, … ,1]𝑡 and 𝑥𝑦𝑾 = [𝑤𝑦 , 1,1, … ,1], and 𝑤𝑥 𝑤𝑦 = ⌊      ⌋.⌈      ⌉.
                                                                                  2        2
                                                    𝑛−𝑘+2              𝑛−𝑘+2
Without loss of generality, we can let 𝑤𝑥 = ⌊            ⌋ and 𝑤𝑦 = ⌈        ⌉. By lemma 6.2
                                                      2                   2
                                                𝑦
𝑊 ′ (𝑇𝑥𝑦
      𝑘
         ) = ‖𝑭𝑘 ⊚ 𝑥𝑦𝑾‖ = ‖𝑭𝑘 ⊚ ( 𝑥𝑦   𝑥
                                         𝑾 × ( 𝑥𝑦𝑾)𝑡 )‖. If we use the definition of 𝐹𝑘 for the
given 𝑘’s and calculate the above formula, we earn the given formulas, 6.10 to 6.12.
                                                103


              APPENDIX B: THE FORMULAS OF THEOREM 6.6
First of all,
                                    𝑥2            𝑥1              𝑥
                                  𝑥2 𝑦2 𝑾   =   𝑥1 𝑦1 𝑾[2: ]  + 𝑥1𝑦11 𝑤1 ⋅ 𝑒1 ,
                                    𝑦2             𝑦1             𝑦
                                  𝑥2 𝑦2 𝑾    =  𝑥1 𝑦1 𝑾[2: ]  + 𝑥1𝑦11 𝑤1 ⋅ 𝑒1
mean
                                           𝑥1
                                         𝑥1 𝑦1 𝑤1
                          𝑥1                                                                     𝑦1
                       𝑥1 𝑦1 𝑤2                                                                𝑥1 𝑦1 𝑤2
                          𝑥1                 0          𝑤𝑥2         𝑤𝑥1                          𝑥1
                       𝑥1 𝑦1 𝑤3                                                                𝑥1 𝑦1 𝑤3
                                                        𝑤𝑥3           0
          𝑥2                                                                      𝑦2
   1.  𝑥2 𝑦2 𝑾   =                 +                 =         +                𝑥2 𝑦2 𝑾   =              +
                                                          ⋮           ⋮
                            ⋮                          [𝑤𝑥𝑘′ ]    [ 0 ]                            ⋮
                         𝑥1                   ⋮                                                 𝑥1
                     [ 𝑥1 𝑦1𝑤𝑘 ′ ]     [     0    ]                                         [ 𝑥1𝑦1𝑤𝑘 ′ ]
            𝑦1
          𝑥1 𝑦1 𝑤1
              0              𝑤𝑦2         𝑤𝑦1
                             𝑤𝑦3           0
                       =           +
                               ⋮            ⋮
                           [𝑤𝑦𝑘′ ]      [ 0 ]
              ⋮
        [     0    ]
Where,
                           𝑥1                                                         𝑦1
                        𝑥1 𝑦1 𝑤1                                                    𝑥1 𝑦1 𝑤1
                           𝑥1             𝑤𝑥1                                         𝑦1             𝑤𝑦1
                        𝑥1 𝑦1 𝑤2                                                    𝑥1 𝑦1 𝑤2
                                          𝑤𝑥2                                                        𝑤𝑦2
           𝑥1                                               𝑦          𝑦1
 𝑥
𝑥𝑦𝑾  =  𝑥1 𝑦1 𝑾   =                 =               and   𝑥𝑦𝑾    =   𝑥1 𝑦1 𝑾 =                  =
                                            ⋮                                                          ⋮
                             ⋮          [𝑤𝑥𝑘′ ]                                          ⋮          [𝑤𝑦𝑘′ ]
                          𝑥1                                                          𝑦1
                      [ 𝑥1𝑦1𝑤𝑘 ′ ]                                                [ 𝑥1𝑦1 𝑤𝑘 ′ ]
Also,
                                                        104


                          2𝑘 ′ − 1           2𝑘 ′ − 3         2𝑘 ′ − 5                   …       1
                          2𝑘 ′ − 3           2𝑘 ′ − 5                               … 1          0
                          2𝑘 ′ − 5                                       …      1        0       0
               𝑭𝑘 =                                                ⋮                                             𝑘 is odd
                                                  ⋮                1                               ⋮
                                 ⋮                1               0                      …        0
                        [       1                 0               0              …       0         0]
                2𝑘 ′ − 2            2𝑘 ′ − 4          2𝑘 ′ − 6                              …        2        0
                2𝑘 ′ − 4            2𝑘 ′ − 6                                        …     2          0        0
                2𝑘 ′ − 6                 ⋮                                   … 2           0          0       0
                                                           ⋮                                                  0
       𝑭𝑘 =                                                                                                        𝑘 is even
                                           ⋮               2
                  ⋮                      2                 0                                                   ⋮
                    2                    0                 0                                           … 0
             [     0                     0                 0                               …          0       0 ]
      Thus,
             𝑥1             𝑥
𝑥1 𝑦1 𝑾 =  𝑥1 𝑦1 𝑾   × ( 𝑥1𝑦11 𝑾)𝑡
                           𝑤𝑥1 . 𝑤𝑦1          𝑤𝑥1 . 𝑤𝑦2         𝑤𝑥1 . 𝑤𝑦3                …                       𝑤𝑥1 . 𝑤𝑦 ′
                                                                                                                            𝑘
                           𝑤𝑥2 . 𝑤𝑦1          𝑤𝑥2 . 𝑤𝑦2               ⋮                  …                       𝑤𝑥2 . 𝑤𝑦 ′
                                                                                                                           𝑘
                           𝑤𝑥3 . 𝑤𝑦1                   ⋮                                 …                       𝑤𝑥3 . 𝑤𝑦 ′
                                                                                                                           𝑘
                 =                  ⋮                         …                                                    ⋮
                          𝑤𝑥 ′ . 𝑤𝑦1                   …                                  ⋮                      𝑤𝑥 ′ . 𝑤𝑦 ′
                              𝑘 −2                                                                                   𝑘 −2      𝑘
                          𝑤𝑥 ′ . 𝑤𝑦1                  …                    ⋮          𝑤𝑥 ′ . 𝑤𝑦 ′                 𝑤𝑥 ′ . 𝑤𝑦 ′
                              𝑘 −1                                                         𝑘 −1          𝑘 −1        𝑘 −1       𝑘
                      [   𝑤𝑥    .  𝑤  𝑦               …            𝑤 𝑥    . 𝑤 𝑦          𝑤  𝑥    . 𝑤  𝑦            𝑤𝑥 ′ . 𝑤𝑦 ′ ]
                             𝑘′        1                               𝑘′       𝑘′ −2         𝑘′        𝑘′ −1          𝑘       𝑘
                            𝑤11          𝑤12          𝑤13               …                      𝑤1𝑘 ′
                            𝑤21          𝑤22               ⋮                   …               𝑤2𝑘 ′
                            𝑤31                  ⋮                                             𝑤3𝑘 ′
                 =                ⋮                      …                                  ⋮
                            𝑤𝑘 ′ −2,1           …                                 ⋮            𝑤𝑘 ′ −2,𝑘 ′
                            𝑤𝑘 ′ −1,1        …                ⋮              𝑤𝑘 ′ −1,𝑘 ′ −1 𝑤𝑘 ′ −1,𝑘 ′
                      [ 𝑤𝑘 ,1     ′        …             𝑤𝑘 ,𝑘 −2 𝑤𝑘 ′ ,𝑘′ −1
                                                            ′ ′                                𝑤𝑘 ′ ,𝑘 ′ ]
                                                                                                                           𝑥2
      Similarly, we can expand               𝑥2 𝑦2 𝑾    in the following with the given vectores                         𝑥2 𝑦2 𝑾  and
  𝑦2
𝑥2 𝑦2 𝑾
                                                                𝑥2              𝑥
                                                   𝑥2 𝑦2 𝑾= 𝑥2 𝑦2 𝑾     × ( 𝑥2𝑦22 𝑾)𝑡
                                                                 105


Therefore, after a tedious calculation by theorem 6.l,
     𝑊 ′ (𝑇𝑥𝑘−2
             2 𝑦2
                  ) − 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ) = ‖𝑭𝑘−2 ⊚ 𝑥2 𝑦2𝑾‖ − ‖𝑭𝑘 ⊚ 𝑥1𝑦1 𝑾‖
                                    ∑       𝑤𝑖𝑗 − 𝑤11                      𝑘 is even,
                               4≤𝑖+𝑗≤𝑘 ′ +1
                                   𝑖,𝑗>1
                       =
                            2(       ∑       𝑤𝑖𝑗 ) +    ∑       𝑤𝑖𝑗 − 2𝑤11   𝑘 is odd.
                                4≤𝑖+𝑗≤𝑘 ′ +1         𝑖+𝑗=𝑘 ′ +2
                           {        𝑖,𝑗>1              𝑖,𝑗>1
                                                  106


               APPENDIX C: FOR COROLLARY 6.8 AND THEOREM 6.9
     For 𝑘 = 5 , if 𝑤𝑥1 = 𝑤𝑦1 = 1, then 𝑤𝑥2 + 𝑤𝑦2 + 𝑤𝑀 = 𝑛 − 2. Using the indexing of
the cycle of 𝑇𝑥51 𝑦1 we have:
𝑊 ′ (𝑇𝑥51𝑦1 ) = 3 + 𝑤𝑦2 + 𝑤𝑥2 ,
𝑊 ′ (𝑇𝑥32𝑦2 ) = (1 + 𝑤𝑥2 )(𝑤𝑦2 + 1),
𝑊 ′ (𝑇𝑥42𝑦1 ) = 2(1 + 𝑤𝑥2 ),
𝑊 ′ (𝑇𝑥41𝑦2 ) = 2(1 + 𝑤𝑦2 ),
𝑊 ′ (𝑇𝑥3𝑀 𝑦1 ) = 1 + 𝑤𝑥1 + 𝑤𝑥2 + 𝑤𝑥𝑀 ,
𝑊 ′ (𝑇𝑥3𝑀 𝑥1 ) = 1 + 𝑤𝑦1 + 𝑤𝑦2 + 𝑤𝑥𝑀 .
     Given 𝑤𝑥1 = 𝑤𝑦1 = 1, 𝑤𝑥2 + 𝑤𝑦2 + 𝑤𝑀 = 𝑛 − 2, and 𝑛 > 6, clearly either 𝑊 ′ (𝑇𝑥41                              2 𝑦1
                                                                                                                        )
or, 𝑊 ′ (𝑇𝑥𝑘−1
             1 𝑦2
                  ) or, 𝑊 ′ (𝑇𝑥𝑘−2
                                𝑀 𝑦1
                                      ) or, 𝑊 ′ (𝑇𝑥𝑘−2𝑀 𝑥1
                                                           ) or, 𝑊 ′ (𝑇𝑥𝑘−2
                                                                         2 𝑦2
                                                                               ) is greater than 𝑊 ′ (𝑇𝑥𝑘1𝑦1 ).
     4:
     equations 6.20 and 6.21
     We know that 𝑊 ′ (𝑇𝑣𝑧         𝑘)
                                        = ‖𝑭𝑘 ⊚ ( 𝑣𝑧    𝑣
                                                          𝑾 × ( 𝑣𝑧𝑧
                                                                     𝑾)𝑡 )‖ and      𝑥𝑦𝑾     =  𝑣
                                                                                               𝑣𝑧𝑾
                                                                                                         𝑧
                                                                                                    × ( 𝑣𝑧 𝑾)𝑡 = [𝑤𝑖𝑗 ].
In the theorem we have              𝑣
                                   𝑣𝑧𝑾     = [1,1, … ,1]𝑡 ,   𝑧
                                                             𝑣𝑧𝑾    = [𝑎𝑖 ]𝑘 ′ , and
                                        𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) − 𝑊 ′ (𝑇𝑣𝑘−1
                                                                 2 𝑧1
                                                                      )=          ∑         𝑤𝑖𝑗 − ∑ 𝑤1𝑗 .
                                                                           3≤𝑖+𝑗   ≤ 𝑘 ′ +1       0<𝑗≤𝑘′
                                                                              𝑖>1, 𝑗<𝑘′
     Thus,
                                                                            𝑘 ′ −1
                           ∑          𝑤𝑖𝑗 − ∑ 𝑤1𝑗 ,             = 𝑎𝑘 ′ − ∑ (𝑘 ′ − 𝑖)𝑎𝑖 ,
                      3≤𝑖+𝑗 ≤ 𝑘 ′ +1          0<𝑗≤𝑘 ′                        𝑖=1
                        𝑖>1, 𝑗<𝑘 ′
                                                                    ′
     and 𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) ≥ 𝑊 ′ (𝑇𝑣𝑘−1    2 𝑧1
                                            ) means, 𝑎𝑘 ′ ≥ ∑𝑘𝑖=1−1(𝑘 ′ − 𝑖)𝑎𝑖 . Similarly, if
                                                              107


        𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) − 𝑊 ′ (𝑇𝑣𝑘−2 2 𝑧2
                                        ) = 2(      ∑         𝑤𝑖𝑗 ) +    ∑       𝑤𝑖𝑗 − 2𝑤11 ,
                                                4≤𝑖+𝑗≤𝑘 ′ +1          𝑖+𝑗=𝑘 ′ +2
                                                   𝑖,𝑗>1                𝑖,𝑗>1
then
                                                                𝑘′
                  𝑊 ′ (𝑇𝑣𝑘1 𝑧1 ) − 𝑊 ′ (𝑇𝑣𝑘−2
                                            2 𝑧2
                                                 ) = 2𝑎1 − ∑(2𝑘 ′ − 2𝑖 + 1)𝑎𝑖 .
                                                               𝑖=2
                                                             ′
And 𝑊 ′ (𝑇𝑣𝑘1𝑧1 ) ≥ 𝑊 ′ (𝑇𝑣𝑘−2  2 𝑧2
                                     ) means 2𝑎1 ≥ ∑𝑘𝑖=2(2𝑘 ′ − 2𝑖 + 1)𝑎𝑖 .
                                                      108


              APPENDIX D: ALGORITHM 6.21 IN pg
import pg
import time
import networkx
from numpy import linalg as LN
import numpy as np
import copy
def vertex_weight(G):
lst=[]
for item in G:
lst.append([item, 1])
    return lst
E =30     # number of edges
t=pg.random_tree(E) # a random tree on E edges
adj_list=t.adjacency_list()
A_L=t.adjacency_list()
tree_leaves=t.leaves()
weihted_adg_t=vertex_weight(adj_list)
nunv=[]
n=E
N=np.zeros((n,n))
while E!= 1:      #Producing matrix of 𝑛𝑢 (𝑣)𝑛𝑣 (𝑢)
   S=tree_leaves
   tree_leaves=[]
   for v in S:
        if E==1:
            break
        u=adj_list[v][0]
        weihted_adg_t[u][1]+=weihted_adg_t[v][1]
                               109


        nunv.append((u, v))
        N[u][v]= weihted_adg_t[v][1]
        N[v][u]= n-weihted_adg_t[v][1]
        adj_list[u].remove(v)
        E-=1
        if len(adj_list[u])==1:
            tree_leaves.append(u)
W=0
for uv   in nunv:
               u=uv[0]
               v=uv[1]
               W+=N[u][v]*N[v][u]
wiener=t.wienerIndex()
impacts=[]
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
xyW=np.zeros((n,n))
xyxW=np.zeros((n,1))
xyyW=np.zeros((1,n))
ccc=[0]
def function (A, B, x, y, k, N_OxyW, Wp, kp,xyW,xyxW,xyyW):
    ccc[0]+=1
    if A and B:
         for a in A:
             Ap = A_L[a][:]
             Ap.remove(x)
             for b in B:
                  xyW2=np.zeros((k+1,k+1))
                  xyxW2=np.zeros((k+1,1))
                  xyyW2=np.zeros((1,k+1))
                                110


                   Bp = A_L[b][:]
                   Bp.remove(y)
                   nxa = N[x][a]
                   nyb = N[y][b]
                   nxny = nxa*nyb       # nxa*nyb
                   nW_d = sum([ xyW[-k+i][-1-i] for i in range(k)])
#||xyW[i+j=k+1]||
                   xyyW2[0][0] = nyb          #[nyb^xyyW]
                   xyyW2[0,1:] = xyyW[0,:]
                   r =nxa * xyyW2             # nxa*[nyb^xyxW]
                   xyxW2[0][0] = nxa          #[nxa^xyxW]
                   xyxW2[1:,0]= xyxW[:,0]
                   c = nyb * xyxW2            # nxa*[nyb^xyxW]
              #print("xyW2[0, :] = r[:] = ",xyW2[0, :] , r[:])
                   #abW
                   xyW2[1:,1:] = xyW
                   xyW2[0, :] = r[0,:]
                   xyW2[:, 0] = c[:,0]
                   xyW2[1,:] -= r[0,:]
                   xyW2[:,1] -= c[:,0]
                   xyW2[1][1]+= nxny
                   n_r=np.sum(r)           #||nxa*[nyb^xyxW]||
                   n_c=np.sum(c)           #||nyb*[nxa^xyxW]||
                   #||O*abW||
                   N_OxyW_k2 = (nxa*xyyW2[0][-1] + nyb*xyxW2[-1][0]
+ N_OxyW -  nW_d )
                   if kp == 2:
                    Wp2 = Wp + 2*(nW_d - N_OxyW + n_r + n_c -
nxa*xyyW2[0][-1] -nyb*xyxW2[-1][0] - 2*nxny)
                   elif  kp ==3:
                                 111


                     Wp2 = Wp + nW_d + 2*( n_r + n_c - 2*nxny -
N_OxyW) -nxa*xyyW2[0][-1] -nyb*xyxW2[-1][0]
                    else:
                     Wp2 = n_r + n_c  - nxny
                     N_OxyW_k2 = n_r + n_c  - 3*nxny
                    #abaW
                    xyxW2[1][0] -=nxa
                    #xyxW[-k-1][0]= N[x][a][1]
                    #abbW
                    xyyW2[0][1] -=nyb
                    #xyyW[0][-k-1]= N[y][b][1]
                    impacts.append((W-Wp2,(a,b)))
                    if kp==2:
                     function (Ap, Bp, a, b, k+1,    N_OxyW_k2, Wp2,
2,xyW2,xyxW2,xyyW2)
                    else:
                     function (Ap, Bp, a, b, k+1,    N_OxyW_k2, Wp2,
3,xyW2,xyxW2,xyyW2)
   for v, nv in enumerate(A_L):
        if len(nv)>1:
           xyW=np.zeros((1,1))
           xyxW=np.zeros((1,1))
           xyyW=np.zeros((1,1))
           for i, x in enumerate(nv):
              A=A_L[x][:]
              A.remove(v)
              for y in nv[i+1:]:
                    B=A_L[y][:]
                    B.remove(v)
                    nvx = N[v][x]
                                  112


                    nvy = N[v][y]
                    xyW[0][0] = nvx*nvy
                    xyxW[0][0] = nvx
                    xyyW[0][0] = nvy
                    N_OxyW = nvx*nvy
                    Wp = N_OxyW
                    impacts.append((W-Wp,(x,y)))
                    function(   A,    B,  x,   y, 1, N_OxyW,
Wp,1,xyW,xyxW,xyyW)
   for uv in nunv:
           u = uv[0]
           v = uv[1]
           nu = A_L[u][:]
           nv = A_L[v][:]
           nu.remove(v)
           nv.remove(u)
           if nu and nv:
              xyW=np.zeros((2,2))
              xyxW=np.zeros((2,1))
              xyyW=np.zeros((1,2))
              #print(u,v,nu,nv)
              for   x in nu:
                  A=A_L[x][:]
                  A.remove(u)
                  for y in nv:
                    #print(x,y)
                    #print(A_L[x],v)
                    #print(A_L[y],v)
                    B=A_L[y][:]
                                  113


                   B.remove(v)
                   nux = N[u][x]
                   nvy = N[v][y]
                   xyxW[0][0] = nux
                   xyxW[1][0] = N[v][u] - nux
                   xyyW[0][0] = nvy
                   xyyW[0][1] = N[u][v] - nvy
                   xyW=xyxW*xyyW
                   N_OxyW = np.sum(xyW)-xyW[-1][-1]
                   Wp = 2*nux*nvy
                   impacts.append((W-Wp,(x,y)))
                   function(   A,   B, x,   y,  2,  N_OxyW, Wp ,
2,xyW,xyxW,xyyW)
   print("done")
   print(n*(n-1)/2-(n-1),ccc, len(impacts))
   impacts.sort()
   print(impacts[0],W,W-impacts[1][1])
   print("done")
   comp=t.edgeImpact()
   print(comp[-1])
                                  114