3.1 Existing approaches for node protection using pcycles
In this section, we present some existing wellknown concepts for node protection using pcycles. NEPC [5] uses pcycles for node protection. Figure 5 illustrates an example of node protection using this concept. The pcycle must traverse all neighboring nodes of the failed node to protect it. The drawback of this concept is that in some cases finding such a pcycle is not possible. Moreover, some pcycles that do not meet this constraint could protect the failed node while reserving less spare capacity. The constraint imposed by this concept is too strict and prevents the protection algorithm from achieving good resource utilization.
Some systems that ensure link and node failure recovery in a multicast session simplify the node protection to reduce the computation time. For example, in the ESHN algorithm, the pcycle has to link: (1) all onelevel downstream nodes of the failed node and (2) one of the upstream nodes in the light tree. Figure 6 illustrates a simple example for protecting a node using the ESHN algorithm. In this example, the failed node (or protected node) is represented by a grey circle, the source node by a green circle, the destination nodes by red circles and the multicast tree by a blue line. The pcycle links the two onelevel downstream nodes of the failed node (nodes belonging to the tree) and the source node (the upstream node of the failed node). Thus, the pcycle satisfies the constraints and can protect the failed node. On node failure, the source node detects the failure and reroutes the multicast traffic through the protection segment (dashed green line). Although this approach relaxes the constraint imposed by NEPC, the protection capacity provided by the pcycles is still not used efficiently as some pcycles could protect a node without meeting the first or second constraint of this approach.
3.2 The proposed concept for node protection using pcycles
In this section, we present our novel concept for protecting nodes in multicast traffic. Before presenting our concept, we will introduce some notation. Let T be a multicast light tree to be protected, s be the source node in T, N_{
f
} be an intermediate node in T, and D={d_{1},d_{2},..,d_{
i
}} be the set of destinations in T that are affected when a failure occurs on the node N_{
f
}.
Theorem
1
A pcycle C_{
j
} in the network can protect the node N_{
f
} if and only if there exists a protection segment [ N_{
a
},N_{
e
}]∈C_{
j
} such that:

1.
The node N _{
a
}∈T, the node N _{
e
}∈T and N _{
f
}∉ [ s,N _{
a
}] where [ s,N _{
a
}] is the segment in T linking the source s to the node N _{
a
}.

2.
∀d _{
k
}∈D, ∃ a node N _{
k
}∈ [ N _{
a
},N _{
e
}] and N _{
k
}∈]N _{
f
},d _{
k
}], where ]N _{
f
},d _{
k
}] is the segment in T linking N _{
f
} to d _{
k
}.

3.
N _{
f
}∉ [ N _{
a
},N _{
e
}].
Proof Once a failure occurs on the node N_{
f
}, the multicast traffic is rerouted through the pcycle C_{
j
} to ensure the survivability of the multicast session. The pcycle must provide a protection segment to deliver the multicast content to all destinations that are affected by the failure of N_{
f
}. This segment is denoted by [ N_{
a
},N_{
e
}].
First, we justify why constraint (1) is required. The extremities N_{
a
} and N_{
e
} of this segment must be in T. In fact, the node N_{
a
} is responsible for injecting the multicast traffic into the protection segment [ N_{
a
},N_{
e
}] when N_{
f
} fails. In addition, N_{
a
} must not be affected by the failure of N_{
f
}, i.e., N_{
a
} must continue to receive the multicast traffic even if a failure occurs on node N_{
f
} (N_{
f
}∉ [ s,N_{
a
}]). The node N_{
a
} must split the incoming light signal into two outgoing signals. The first is injected into the protection segment and the second is forwarded to the downstream node of N_{
a
} in the light tree T. The node N_{
e
} is the last intersection node between T and C_{
j
}.
Second, we prove the necessity of constraint (2). To ensure failure recovery, we must make sure that all destinations affected by the failure of N_{
f
} continue to receive the multicast traffic through the protection segment [N_{
a
},N_{
e
}]. Two scenarios are possible for delivering the multicast traffic to an affected destination d_{
k
}. In the first, the segment [ N_{
a
},N_{
e
}] carries the multicast traffic directly to d_{
k
}, i.e., the protection segment traverses the node d_{
k
}. In the second scenario, the segment [ N_{
a
},N_{
e
}] carries the traffic to the destination through an intermediate node N_{
k
}. The node N_{
k
} must be an upstream node of d_{
k
} and a downstream node of N_{
f
} in the light tree. This constraint ensures that the failed node N_{
f
} does not belong to the segment [ N_{
k
},d_{
k
}] of the light tree. The node N_{
k
} splits the incoming signal into two signals. The first is sent to the next node in the protection segment to ensure that the remaining affected destinations will receive the multicast content. The second is forwarded to the downstream node of N_{
k
} in the light tree to reach d_{
k
}.
Finally, we prove that constraint (3) is necessary. We must make sure that the protection segment is not affected by the failure of N_{
f
}. Therefore, the protection segment [N_{
a
},N_{
e
}] should not traverse the node N_{
f
}.
3.3 Example
In Figure 7, we provide an example of a pcycle that can protect the node N_{
f
} based on our concept. The set of destinations affected by the failure of N_{
f
} is D={d_{1},d_{2},N_{
e
}}. This pcycle has two original characteristics that other node protection concepts [5–7] do not have. First, it can traverse the protected node. Second, it does not have to traverse all affected destinations or neighboring nodes of the protected node. The pcycle provides a protection segment represented with a dashed green line in the figure. The node N_{
a
} activates the pcycle by injecting the multicast traffic into the protection segment [ N_{
a
},N_{
e
}]. This segment carries the traffic to d_{2} through the intermediate node N_{2}, and to d_{1} and N_{
e
} directly as it traverses them.