Using Cayley Codes to Represent Trees in GAs

Outline

I Introduction

I Cayley Codes.

I Decoding and Encoding algorithm for the Dandelion Code.

I The Dandelion Code has Linear Complexity.

I Locality of the Dandelion Code

I The Bipartite Dandelion Code

I The Rainbow Code

PDF processed with CutePDF evaluation editionwww.CutePDF.com

Introduction

Many network optimization problems entail finding an optimal tree with respect to a specific objective function. Such problem are often computationally hard, and in recent years, many researchers have deployed genetic algorithms in an attempt to determine high-quality solutions.

It is well-established that the performance of any GA depends critically on the representation that is adopted and the operators applied to this representation. Unfortunately, there are so many ways to represent trees within a GA that there is little consensus as to which representation is “best”.

Suggested Properties

Palmer and Kershenbaum suggest that an effective tree representation must satisfy five properties:

1. Capable of representing all possible trees.(full coverage) 2. Same number of encodings (zero biased).

3. Representing only trees. (perfect feasibility) 4. Easy to go back and forth between the encoding

representation and tree representation. (efficiency) 5. Locality.

Key Definitions

1. C_n denotes the set of strings consisting of exactly (n-2) integers from [1,n]=1,2,. . . ,n. The strings C_n will be termed Cayley strings.

2. Tn denotes the set of labeled trees on the vertex set [1,n].

3. |T_n| = nⁿ⁻², the enumeration is known as Cayley’s formula.

4. |T_n| = |C_n|, ∀n ≥ 2.

5. Cayley Code will be termed to refer to any one-to-one mapping between Tn and Cn.

⇒ (nⁿ⁻²)! Cayley Codes.

Using Cayley Codes to Represent Trees in GAs

1. Cayley Codes satisfies full coverage, zero bias, and perfect feasibility.

2. Mutating and crossing-over two Cayley strings will always produce valid Cayley strings.

3. Any Cayley code could be used as a tree representation within a GA.

4. Unfortunately, for the vast majority of the (nⁿ⁻²)! possible Cayley codes, the correspondence between trees and strings is highly disordered. Researchers have identified several Cayley codes that possess significant structure, and that may regarded as viable GA representations.

Pr¨ ufer-like Cayley Codes

1. Devised in 1918 by Heinz Pr¨ufer.

2. The string corresponding to a tree is generated by sequentially deleting the tree’s leaves and recording the neighbors of these leaves.

3. Pr¨ufer-like Cayley codes also possess efficiency (Prop. 4), but almost always perfom poorly as genetic representations, as they have low locality.

High-Locality Cayley Codes

1. Picciotto set out the mathematical foundations for three Cayley codes: the Blob Code, the Happy Code, and Dandelion Code.

2. Picciotto thought that “the codes themselves may not be useful for much yet”.

3. In 2001, Julstrom deployed the Blob Code as genetic representation. He showed that the code possesses high locality.

4. Thompson showed that the Dandelion Code has even higher locality.

Notation and Terminology

1. Picciotto’s Dandelion Code is identical to the θ_n bijection between Tnand Cndevised in 1986 by E˘gecio˘glu and Remmel.

2. The (n-2) elements of any string from C_n will be indexed from 2 to (n-1), rather than from 1 to (n-2).

Decoding Algorithm

1. Define the function φ_D : [2, n − 1] → [1, n] such that φD(i ) = di for each i ∈ [2, n − 1].

2. Let the cycles associated with the function φ_D be

Z1, Z2, . . . , Zt and let bi be the minimum element in cycle Zi. WLOG, assume that the cycles are recorded such that b_i is the rightmost element of Z_i, and that b_i < b_j whenever i < j . 3. From a single list π of the elements in Z₁, Z₂, . . . , Z_t in the

order they occur in this cycle list, from the list element of Z1

throught to the last element of Zt.

4. To construct the tree T ∈ Tt corresponding to D, take a set of n isolated vertices (labled with the integers form 1 to n), create a path from vertex 1 to vertex n by following the list π from left to right, and then create the edge (i , di) for every i ∈ [2, n − 1] that does not occur in the list π.

Encoding Algorithm

1. Find the unique path from 1 to n in T, and let π be the ordered list of intermediate vertices.

2. Recover the cycles Z_i by writing π in a left-to-right list, and closing a cycle immediately to the right of each right-to-left minimum(i.e., each element that is smaller than all elements to its right).

3. The Dandelion string corresponding to T is the unique string D = (d2, d3, . . . , dn−1) such that:

I the cycles of the function φ_D(i ) = d_i are precisely Z_i

I for each i ∈ [2, n − 1] that does not occur in π, the first vertex on the path from vertex i to vertex n in the tree T is d_i(i.e., d_i= succ(i ), where vertex n is regarded as the root of T ).

Example(Decoding)

The Dendelion string D =

(19, 7, 1, 3, 18, 3, 23, 19, 10, 1, 2, 25, 4, 4, 18, 7, 9, 8, 6, 8, 5, 9, 6) ∈ C₂₅ will be docoded into the corresponding tree T ∈ T₂₅. Step1, cosider the function φ_D that maps i into d_i:

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ 19 7 1 3 18 3 23 19 10 1 2 25 4 4 18 7 9 8 6 8 5 9 6 Step2, three distinct cycles:

I two-cycle (3,7) (= Z₁)

I four-cycle (8,23,9,19) (= Z₂)

I one-cycle (10) (= Z₃)

Example(Decoding)

Step3, the list π is found to be (7, 3, 23, 9, 19, 8, 10).

Step4, the tree T corresponding to the Dandelion string D is the unique T ∈ T25 that contains the path 1-7-3-23-9-19-8-10-25 and the 16 undirected edges {(i , d_i) : i ∈ [2, 24]\π}

Result

Example(Encoding)

Step1, determine the unique path from vertex 1 to vertex n in T . The simplest way to do this is to temporarily regard the tree T as being rooted at vertex 25, and determine the successor succ(i ) of every vertex i ∈ [2, 24].

i succ(i ) i succ(i ) i succ(i ) i succ(i )

1 7 7 3 13 25 19 8

2 19 8 10 14 4 20 6

3 23 9 19 15 4 21 8

4 1 10 25 16 18 22 5

5 3 11 1 17 7 23 9

6 18 12 2 18 9 24 6

Once this table has been constructed, it is easy to see that π = (7, 3, 23, 9, 19, 8, 10)

Example(Encoding)

Step2 recovers the cycles Z_i from the path π.

|7, 3, 23, 9, 19, 8, 10|

Place a vertical bar to the immediate right-to-left minimum in the list.(i.e., each element that is smaller than every element to its right), excluding the rightmost element.

| 7, 3 | 23, 9, 19, 8 | 10 |

Example(Encoding)

Step3 determines the Dandelion string D corresponding to T by constructing the mapping diagram for φD.

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓

7 3 23 19 10 8 9

Then fill in the empty spaces in the mapping diagram by writing succ(i ) underneath i for each i ∈ [2, n − 1]\π.

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ 19 7 1 3 18 3 23 19 10 1 2 25 4 4 18 7 9 8 6 8 5 9 6 Thus, the Dandelion string is constructed.

Visual formulation of the Decoding Algorithm

Consider the functional digraph G_D of the function φ_D associated with D.

The functional digraph G_D consists of (c + 2) connected

components for some integer c ∈ [0, n − 2]: a tree rooted at vertex 1, a tree rooted at vertex n, and c other components.

I Label the cycles within G_D as Z1, Z2, . . . , Zc in such a way that the relation b₁ < b₂ < . . . < b_c is satisfied, where b_i denotes the minimum element in cycle Zi.

I a_i: the vertex pointed to by the unique edge leaving b_i in the digraph, so that ai = φD(bi).

I The c edges in GD of the form (bi → a_i) will be referred to as the back edges of G_D

I Delete back edges and add the following (c+1) bridge edges:

(1 → a1), (b1→ a₂), . . . , (bc−1→ a_c), (bc → n)

Example

Linear Implementation of the Decoding Algorithm

1. Let Visited(i ) = 0 and IsMin(i ) =0 for each i ∈ [2, n − 1]. Let orbit=1, let u = 2, and let v = 2.

2. Set Visited(v ) = orbit.

3. Let the new value of v be φD(v ).

4. If Visited(v ) = orbit, go to stage 5. If v = 1, or v = n, or 0 < Visited(v ) < orbit, go to stage 6. Otherwise, go to stage 2.

5. Determine the minimum element min within the cycle (v , φ_D(v ), φ_d(φ_D(v )), . . . , v ), and set IsMin(min) = 1.

6. Repeatedly increment u until Visited(u)=0 or u = n 7. If u = n, then terminate. If u < n, then increment orbit by

one, set v = u and go to stage 2.

Linear-Time Implementation of the Encoding Algorithm

1. Let pos=1

2. Let v be the element in position pos of the queue.

3. Let Preq(v ) denote the set of predecessors of v (i.e., all neighbors of v except succ(v ), where succ(n) is null).

4. Set succ(w )=v for each vertex w in Pred(v ).

5. Append all the vertices in Preq(v ) to the end of the queue.

6. If pos=n, then terminate. Otherwise, increment pos by one and go to stage 2.

Definition:

Locality means that small changes to the genotype should always lead to small

changes in the corresponding phenotype.

Genotype V.S. Phenotype

Genotype is the space of Cayley String Phenotype is the space of trees

Why do we need locality?

Because an effective GA representation must

possess locality.

In the space of Cayley strings, the distance

between two strings is the number of position in which they differ. (i.e. Hamming distance)

In the space of trees, the distance between two trees T ₁ and T ₂ is the number of edges that

belong to T ₁ but not T _2. (the number of edge swaps required to transform T ₁ into T ₂ )****

Therefore, the distance between two distinct

strings (trees) is in the range [1, n-2] ([1, n-1]).

Previous research shows that if two

Dandelion strings are adjacent (i.e. the

distance between them in the string space is one), then the distance between the

trees corresponding to these strings is

never more than five, for any value of n.

Dandelion code has asymptotically optimal locality and asymptotically optimal

expected locality.

No Cayley code can have optimal locality.

Namely, the Dandelion code s locality

bound of five is the tightest locality bound

of any Cayley code.

Given n 3, there are n ^(n-2) (n-1)(n-2) possible mutation events associated with the Dandelion code (that is, n ^(n-2) choices for the original

Dandelion string D C _n , (n-2) choices for the component of D to undergo mutation, and (n-1) choices for the new value in that component.) For each of these possible mutation events, the tree corresponding to the original string and the tree corresponding to the mutated string are

separated in the tree space by some distance

[1, n-1]

In the two tables, we can observe that for larger values of n, it is computationally

costly to examine the space of mutation events exhaustively. However, it is

possible to estimate the distribution of by generating a large number of random

mutation events.

Let D C _n be a Dandelion string, and let D ^* C _n be the Dandelion string obtained from D when d is changed into d ^* [1, n] for some [2, n-1], where d ^* d .

Let T T _n denote the tree corresponding to the original string D, and let T ^* T _n denote the tree corresponding to the mutated string D ^* (under the Dandelion Code).

In this section, we prove that the tree distance between T and T ^* never exceeds five i.e., T

and T ^* always have at least (n-6) common edges.

Let G _D be the functional digraph corresponding to the original Dandelion string D.

Clearly, G _D consists of (c+2) connected components for some integer c [0, n-2]:

a tree rooted at vertex 1 (now referred to as component C ₀ ), a tree rooted at vertex n (now referred to as component C _c+1 ), and c other

components, each consisting of a directed cycle with a tree (possibly the empty tree) attached to each

cycle vertex, with all the edges of these trees directed

toward the cycle.

As before, the cycles G _D within are labeled as Z ₁ , Z ₂ , , Z _C in such a way that the relation b ₁ b ₂

b _C is satisfied, where b _i denotes the minimum element in Z _i cycle.

The component of G _D containing Z _i is then

labeled C _i , so that the (c+2) components of G _D

are C ₀ , C ₁ , ,C _C+1 . As before, for each i [1, c],

let a _i be the vertex pointed to by the unique edge

leaving b _i in the digraph G _D , so that _D (b _i ) = a _i .

Let X _i denote the set of noncyclic vertices in component C _i for each i [1, c], and

define X ₀ = C ₀ and X _C+1 = C _C+1 .

For each noncyclic vertex , let T

denote the subtree of G _D , rooted at vertex (i.e., the subtree containing all the

ancestors of , along with itself). Thus, the vertex belongs to T if and only if

lies on the unique path from to n in T.

We are now ready to analyze the

relationship between the tree T and the tree T ^* . Note that the mutation d d ^* causes precisely one change in the functional digraph G _D :

the edge ( d ) is deleted, and replaced

by the edge ( d ^* ). Therefore, G _D and

G _D* differ in only one edge, but T and T ^* may

differ from each other in a more complex way.

The analysis divides naturally into four

mutually exclusive and exhaustive cases.

Case 1: X _S for some s, and d ^* ! T . Case 2: X _S for some s, and d ^* T . Case 3: Z _S for some s, and d ^* C _j ,

where j s.

Case 4: Z _S for some s, and d ^* C _S .

Case 1: X _S for some s, and d ^* ! T . In this case, the vertex is a noncyclic

vertex in component C _S , and the vertex d ^* is not an ancestor of . Thus, the

functional digraphs C _D and C _D* have the

same cycles. It follows immediately that T

and T ^* differ only in one edge: E(T ^* )\E(T ) =

{( , d ^* )} and E(T)\E(T ^* ) = {( , d )}.

Case 2: X _S for some s, and d ^* T . In this case, the vertex is a noncyclic

vertex in component C _S , and the vertex d ^* is an ancestor of .

Replacing ( d ) with ( d ^* ) creates another component in the

functional digraph G _D* , and this component

contains a cycle .

Let be the minimum element of the

cycle , and define = _D* ( ). Define t [0, c] such that b _t b _t+1 , where b ₀

= 1 and b _C+1 = n. When the cycles of G _D*

are ordered by minimum element, the

cycle will appear between Z _t and Z _t+1 .

Thus, in the worst case, E(T ^* )\E(T ) = {( ,

d ^* ), (b _t , ), ( , a _t+1 )} and E(T)\E(T ^* ) =

{( , d ), (b _t , a _t+1 ), ( , )}.

Case 3: Z _S for some s, and d ^* C _j , where j s.

In this case, the vertex is a cyclic vertex in component C _s , and the vertex d ^*

belongs to a different component, C _j .

Replacing ( d ) with ( d ^* ) splits the cycle Z _S to form a path leading into

component C _j (and eventually, into cycle Z _j ). Thus, component C _s is not present in G _D* , and the cycle Z _S disappears from the canonical cycle ordering. Thus, in the

worst case, E(T ^* )\E(T ) = {( , d ^* ), (b _s-1 ,

a _s+1 ), (b _s , a _s )} and E(T)\E(T ^* ) = {( , d ),

(b _s-1 , a _s ), (b _s , a _s+1 )}.

Case 4: Z _S for some s, and d ^* C _S . In this case, the vertex is a cyclic vertex in component C _S , and the vertex d ^*

belongs to the same component.

When ( d ) is replaced with (

d ^* ), the component C _S still contains

precisely the same vertices, but the cycle

it contains is no longer Z _S , but some new

cycle, .

Let be the minimum element of the cycle , and define = _D* ( ). Define t [0, c] such that b _t b _t+1 , where b ₀ = 1 and b _C+1 = n.

When the cycles of G _D* are ordered by minimum element, the cycle Z _S will no longer appear, and the cycle will appear between Z _t and Z _t+1 .

Thus, in the worst case, E(T ^* )\E(T ) = {( , d ^* ), (b _s-1 , a _s+1 ), (b _t , ), ( , a _t+1 ),(b _s , a _s )} and

E(T)\E(T ^* ) = {( , d ), (b _s-1 , a _s ), (b _s , a _s+1 ), (b _t ,

a _t+1 ),( , )}

The functional digraph G _D of the function _D associated with the original Dandelion string D = (6, 3, 6, 4, 5)

1 3 6 5 4 7

2

C

C

C

C

The functional digraph G _D of the function _D associated with the original Dandelion string D = (6, 3, 6, 4, 5)

1 3 6 5 4 7

2

C

C

C

C

The functional digraph G _D of the function _D associated with the original Dandelion string D = (6, 3, 6, 4, 5)

1 3 6 5 4 7

2

C

C

C

C

The tree T T ₇ corresponding to the original Dandelion String D = (6, 3, 6, 4, 5)

1 3 6 5 4 7

2

C

C

C

C

The functional digraph G _D of the function _D associated with the original Dandelion string D = (6, 3, 6, 2, 5)

1 6 5 2 3 7

4

C

C

C

C

The functional digraph G _D of the function _D associated with the original Dandelion string D = (6, 3, 6, 2, 5)

1 6 5 2 3 7

4

C

C

C

C

The functional digraph G _D of the function _D associated with the original Dandelion string D = (6, 3, 6, 2, 5)

1 6 5 2 3 7

4

C

C

C

C

The functional digraph G _D of the function _D associated with the original Dandelion string D = (6, 3, 6, 2, 5)

1 6 5 2 3 7

4

C

C

C

C

D. The Dandelion Code Has

Asymptotically Optimal Locality and

Asymptotically Optimal Expected Locality

As mentioned before, the probability that a random single-element mutation to a random Dandelion string is a perfect mutation (i.e.,

causes a single edge change in the underlying tree) is close to one.

Moreover, the expected number of edge

changes caused by such a mutation is also close to one.

In fact, it is possible to show that the Dandelion

Code has asymptotically optimal locality.

the following asymptotic results are quoted for a random mapping from [1, n] to [1, n], selected uniformly at random from n ⁿ the possible mappings:

1) the total number of cyclic elements (i.e., elements belonging to some cycle) is

O(n ^(1/2) );

2) the expected number of ancestors of a

random element is O(n ^(1/2) ).

Since a random Dandelion string D

corresponds to a random mapping _D

from [2, n-1] to [1, n], its functional digraph G _D follows these asymptotics. Thus, as n tends to infinity, the proportion of

mutations in which is noncyclic and d ^*

is not an ancestor of tends to one.

Since this situation corresponds to Case 1) of the proof presented in Section V-B, it

follows that the probability of perfect

mutation tends to one as n tends to infinity.

Thus, the Dandelion Code has

asymptotically optimal locality.

Since is restricted to the interval [1, 5], this result also implies that the Dandelion Code has asymptotically optimal expected locality (i.e., the expected number of edge changes caused by a random single-element mutation to a random

Dandelion string tends to one as tends to infinity).

To see why this is so, observe that 1 E( ) p + 5(1-p) = 5 4p, where p equals P( =1).

Thus, as tends to infinity, tends to one (from

below), and E( ) tends to one (from above).

Therefore, we conclude that the Dandelion

Code s locality actually increases as the size of problem instance goes up.

As n increases, not only does the fixed locality

bound of five become increasingly negligible

relative to the size of the search space, but the

probability that a random string mutation is not a

perfect mutation becomes vanishingly small, and

the expected number of edge changes caused

by a random string mutation rapidly approaches

one.

The Dandelion Code has high locality

because the correspondence that it sets

up between trees and strings has a natural structure. In particular, the occurrence of a certain value at a certain position within a Dandelion string almost always has a

consistent meaning.

Specifically, if a Dandelion string D = (d ₂ , d ₃ , , d _n-1 ) is decoded into the corresponding tree

under the Dandelion Code, then (i, d _i ) will be an edge in T for every that is not a cycle minimum in the functional digraph G _D .

In fact, the Dandelion Code s decoding algorithm maximizes the number of values of i for which

this property is true, since in the creation of the tree T, only one edge is removed from each

cycle in G _D .

Moreover, the decoding algorithm specifies that the bridge edges which replace the back edges are arranged so as to bridge the broken cycles in increasing order of minimum element.

Thus, changing a single element of a Dandelion string has only a small impact on the

corresponding tree, even if the mutation alters a

cycle of the functional digraph.

For any n 5, consider the Prufer string (3, 4, , n-1, n).

The tree T T _n corresponding to P (under the Prufer

Code bijection) contains the edges (i, i+2) for each i [1, n-2], along with the edge (n-1, n).

However, if the last element of P is mutated from the

value n to the value 1, to create the mutated string P ^* =

(3, 4, , n-1, 1), then the tree T ^* T _n corresponding to

P ^* contains the edges (i, i+1) for i [2, n-2], along with

the edges (1, n-1) and (1, n). Clearly, T and T ^* have no

common edges; therefore, the Prufer Code possesses

no fixed locality bound.

1 3 5 4 2

With Prufer string (3, 4, 5)

2 3 4 1 5

With Prufer string (3, 4, 1)

The authors conjecture that no other

Cayley code possesses a tighter bound (for all values of n). (Of course, even if a Cayley code with a smaller locality bound was shown to exist, it would only be a

useful GA representation if it possessed

sufficient structure to allow an efficient

transition between trees and strings.)

It is known, however, that no optimal-

locality Cayley code (i.e., a Cayley code such that adjacent strings always

correspond to adjacent trees) can exist for any n 4.

The easiest proof of this result is by

contradiction.

Suppose that an optimal-locality Cayley code does indeed exist. Observe that for any n 4, there exist trees T ₁ , T ₂ T _n with no edges in common.

By definition, T ₁ and T ₂ are separated by a

distance of (n-1) in the tree space. However, if Q ₁ and Q ₂ are the Cayley strings corresponding to T ₁ and T ₂ under the optimal-locality Cayley

code, then Q ₁ can be transformed into Q ₂ with

(n-2) mutations in the string space.

Since the Cayley code under

consideration has optimal locality, this

means that the trees T ₁ and T ₂ can differ in no more than (n-2) edges in other words, they must have at least one common edge.

This establishes the required contradiction,

as T ₁ and T ₂ have no common edges.

Real-world network doesn t take the form of a complete graph.

Many extensions of Prufer code perform

poorly, as they inherit low locality.

Complete graph K _k1,k2 consists of two layers of vertices V ₁ ,V ₂ containing k ₁ and k ₂ vertices

A spanning tree touches every vertex in [1, k ₁ + k ₂ ], and use only the edge of K _k1,k2 will be termed Bipartite Trees

|T _k1,k2 | = k ₂ ^k

^-1 k ₁ ^k

^-1

D _k1,k2 be the set of strings D = (d ₂ ,d ₃ ,d _k

+k

-1 ) such that

d _i in V ₂ =[k ₁ +1,k ₁ +k ₂ ] for each i in [2,k ₁ ] d _i in V ₁ =[1,k ₁ ] for each i in [k ₁ +1,k ₁ +k ₂ -1]

|D _k1,k2 | = |T _k1,k2 | = k ₂ ^k

^-1 k ₁ ^k

^-1

D = (11,13,12,14,10,15,12,12,5,2,9,5,6) V ₁ = [1,9] k ₁ = 9 and V ₂ = [10,15] k ₂ = 6

2 3 4 5 6 7 8 9 10 11 12 13 14 11 13 12 14 10 15 12 12 5 2 9 5 6

Z ₁ =(11,2), Z ₂ =(14,6,10,5), Z ₃ =(12,9)

= (11,2,14,6,10,5,12,9)

T contains path 1-11-2-14-6-10-5-12-9-15

1 2 3 4 5 6 7 8 9

10 11 12 13 14 15

= (11,2,14,6,10,5,12,9)

T contains path 1-11-2-14-6-10-5-12-9-15 (3,13) (4,12) (7,15) (8,12) and (13,5)

1 2 3 4 5 6 7 8 9

10 11 12 13 14 15

Find path 1-11-2-14-6-10-5-12-9-15

= (11,2,14,6,10,5,12,9)

Split into (11,2), (14,6,10,5), (12,9)

For each i not lying in , set d _i equal to the

first vertex of the path from i to 15.

Every cycle must have even length.

Each cycle s rightmost belong to V ₁ leftmost belong to V ₂

T _k1,k2 is obtained when (i,d _i ) corresponding to

noncyclic element are added

Choose a mutation position u from [2,k ₁ +k ₂ -1]

Reset d _u with an integer from the set V*

V* = V ₂ if u in [2,k ₁ ]

= V ₁ if u in [k ₁ +1,k ₁ +k ₂ -1]

Uniform crossover and one-point crossover

n = k ₁ +k ₂ in {150,600,2400}

MAX( ) <= 5

n ~ infinity => P( =1) and E( ) ~ 1

Locality of T _k1>k2 is higher than T _k2>k1

New representation for transportation problems

Random network generation

High locality and linear complexity

Complete Layered Graph L _3,6,6,5,4

Each of the (k ₁ -1) element of substring R ₁ = (r ₂ ,r ₃ , ,r _k

) belongs to the set V ₂

Each of the (k _l -1) element of substring R _l = (r _q

+1,r _q

+2, ,r _n-1 ) belongs to the set V _l -1

i in [2,l-1], one element satisfied r _i = i

other element of R _i belongs to V _l-1 U V _l+1

Denote cycles by Z ₁ , Z ₂ , Z _t and

bi (rightmost) be the minimum element of Z _i (b _i < b _j whenever i < j)

Define the color of cycle Z _i , _i in [1,l ]

Shift each one-cycle within the cycle ordering Relabel cycles as Y ₁ ,Y ₂ , Y _t in new order

Form

Construct T corresponding to R

Suppose l _3,6,6,5,4 so that l = 5 , n = 24

R = (4,7,2,15,1,14,12,9,6,20,5,16,14,8,13, 17,21,24,11,18,20,20)

Z ₁ =(4,2), Z ₂ =(15,8,12,5), Z ₃ =(9),Z ₄ =(20,11) Z ₅ =(16,13), Z ₆ =(14), Z ₇ =(17), Z ₈ =(21,18)

Color ( ₁ , ₂ , , ₈ ) = (1,2,2,3,3,3,4,4)

Shift and relabel Y1=(4,2),

Y2=(9), Y3=(15,8,12,5)

Y4=(14), Y5=(20,11), Y6=(16,13) Y7=(17), Y8=(21,18)

= (4,2,9,15,8,12,5,14,20,11,16,13,17,21,18)

Add other 7 edges (3,7), (6,1), (7,14), (10,6),

(19,24), (22,20), (23,20)

Find the unique path from 1 to n ( in fact) Recover cycles {Y _i } by two step

Close a cycle after each right-to-left minimum in For each _i in [2,l-1], split the leftmost cycle of color

i after its first element to form two separate cycles.

The cycles in are precisely

For each i in [2,n-1] not lying in ,the first

vertex on the path from i to n is r _i .

= (4,2,9,15,8,12,5,14,20,11,16,13,17,21,18) Get (4,2) (9,15,8,12,5) (14,20,11) (16,13)

(17) (21,18) at first

(9,15,8,12,5)=> (9) & (15,8,12,5) (14,20,11)=> (14) & (20,11)

R = (4,7,2,15,1,14,12,9,6,20,5,16,14,8,13,

17,21,24,11,18,20,20) finally.

Choose a mutation position u in [2,n-1]

define j such that r _u in the set of V _j

If r _u is not a fixed point choose new value from A _j If r _u is a fixed point then make two mutation

(choose v, let r _u = r _v , r _v = v)

Mask Crossover

Perfect Feasibility, Full Converge, Zero Bias

Provides a bijection between trees and strings.

Linear Complexity

Linear-time procedure require minor alterations.

High Locality

Dandelion code and its extensions satisfy all five of the desirable properties identified by Palmer and Kershenbaum.

Dandelion code and its extension should be

used in preference to other Cayley codes,

particularly the widely used Prufer code.