Constructing Hamiltonian paths and Hamiltonian cycles in $D_{2,2}$ with faulty elements.

The program for constructing Hamiltonian paths between any two distinct nodes in D_{2,2} is as follows:

import networkx as nx

def constructGraph(n,k,I):
    f1=n*1+1
    f2=n*f1+1
    G = nx.Graph() 
    for x1 in range(0,f1):
        for x2 in range(0,f2):
            G.add_node(str(x2)+','+str(x1))
    for i in range(0,f2):
        for j in range(0,f1):
            for l in range(j+1,f1):
                G.add_edge(str(i)+','+str(j), str(i)+','+str(l), weight=1)
    for node in G.nodes:
        node = node.split(',')
        x2=int(node[0])
        x1=int(node[1])
        y1=f1-1-x1
        y2_list=[]
        for j in range(1,n+1):
            y2_list.append((n*x1+x2+j)%f2)
        for y2 in y2_list:
            G.add_edge(str(x2) + ',' + str(x1), str(y2) + ',' + str(y1))
    return G

def dfs(graph, visited, start, end):
    visited.append(start)
    if start == end and len(visited) == len(graph):
        return visited
    for next_node in graph[start]:
        if next_node not in visited:
            path = dfs(graph, visited, next_node, end)
            if path:
                return path
    visited.pop()

def hamiltonian_path(graph,start,end):
    visited = []
    path = dfs(graph, visited, start, end)
    if path:
        return path
    else:
        return "No hamiltonian path exists"

n=2
k=2
G=constructGraph(n,k,0)
N = []
for i in G.nodes:
    N.append(i)
for start in N:
    for end in N:
        if start!=end:
            path=hamiltonian_path(G,start,end)
            print(path)

The program for constructing Hamiltonian paths between any two fault-free distinct nodes in D_{2,2} is as follows, where the faulty element set |F| ≤ nk-3.

import networkx as nx
import random

def constructGraph(n,k,I):
    f1=n*1+1
    f2=n*f1+1
    G = nx.Graph() 
    for x1 in range(0,f1):
        for x2 in range(0,f2):
            G.add_node(str(x2)+','+str(x1))
    for i in range(0,f2):
        for j in range(0,f1):
            for l in range(j+1,f1):
                G.add_edge(str(i)+','+str(j), str(i)+','+str(l), weight=1)
    for node in G.nodes:
        node = node.split(',')
        x2=int(node[0])
        x1=int(node[1])
        y1=f1-1-x1
        y2_list=[]
        for j in range(1,n+1):
            y2_list.append((n*x1+x2+j)%f2)
        for y2 in y2_list:
            G.add_edge(str(x2) + ',' + str(x1), str(y2) + ',' + str(y1))
    return G

def dfs(graph, visited, start, end):
    visited.append(start)
    if start == end and len(visited) == len(graph):
        return visited
    for next_node in graph[start]:
        if next_node not in visited:
            path = dfs(graph, visited, next_node, end)
            if path:
                return path
    visited.pop()

def hamiltonian_path(graph,start,end):
    visited = []
    path = dfs(graph, visited, start, end)
    if path:
        return path
    else:
        return 1

n=2 
k=2
G=constructGraph(n,k,0)
N = []
Nodes = []
Edges = []
for i in G.nodes:
    N.append(i)
    Nodes.append(i)
for i in G.edges:
    N.append(i)
    Edges.append(i)
sum = 0
for start in Nodes:
    for end in Nodes:
        if start!=end:
            G1 = constructGraph(n,k,0)
            FaultyNumber = random.randrange(0, n*k-3+1)
            print("Number of faults=", FaultyNumber)
            print("Start Node：",start)
            print("End Node：",end)
            ST = [start,end]
            F = [x for x in N if x not in ST]
            FaultySet = random.sample(F, FaultyNumber)
            print("Faulty Element Set：",FaultySet)
            for faulty in FaultySet:
                if faulty in Nodes:
                    G1.remove_node(str(faulty))
                if faulty in Edges:
                    print(faulty)
                    faulty = str(faulty).replace("(","")
                    faulty = str(faulty).replace(")", "")
                    print(faulty)
                    N1=faulty.split(', ')
                    N1[0]=N1[0].replace("'", "")
                    N1[1] = N1[1].replace("'", "")
                    G1.remove_edge(N1[0],N1[1])
            print(len(G1))
            path=hamiltonian_path(G1,start,end)
            if path==1:
                sum+=1
            print(path)
print("The number of times that the Hamiltonian path cannot be found is：",sum)

The program for constructing Hamiltonian cycles in D_{2,2} is as follows, where the faulty element set |F| ≤ nk-2.

import networkx as nx
import random
import numpy as np

def constructGraph(n,k,I):
    f1=n*1+1
    f2=n*f1+1
    G = nx.Graph() 
    for x1 in range(0,f1):
        for x2 in range(0,f2):
            G.add_node(str(x2)+','+str(x1))
    for i in range(0,f2):
        for j in range(0,f1):
            for l in range(j+1,f1):
                G.add_edge(str(i)+','+str(j), str(i)+','+str(l), weight=1)
    for node in G.nodes:
        node = node.split(',')
        x2=int(node[0])
        x1=int(node[1])
        y1=f1-1-x1
        y2_list=[]
        for j in range(1,n+1):
            y2_list.append((n*x1+x2+j)%f2)
        for y2 in y2_list:
            G.add_edge(str(x2) + ',' + str(x1), str(y2) + ',' + str(y1))
    return G

'''
Defining our safe vertex as something which is not in our path
'''
def safeVertex(node):
    if (node in path):
        return False
    return True

'''
Defining our DFS and Backtracking Logic
'''
def cycleDetection(E, n, root):
    path.append(root)
    # Seeing all the neigbours of the current root
    for i in E[root]:
        # Checking if our vertex satisfies the safe Vertex
        if (safeVertex(i)):
            # Checking if a cycle has already been detected or not in the
            # ---------------------previous recursion--------------------
            if (cycleDetection(E, n, i)):
                return True

    # Checking if our current path has all the vertices
    if (len(path) == n):
        # If there is an edge from last vertex to the first vertex in our path
        # -------------then we have an hamiltonian cycle---------------------
        if (path[0] in E[path[len(path) - 1]]):
            return True
        else:
            return False
    # once we are done we remove that particle from the iteration
    path.pop()

'''
Printing True or False based on our output from Cycle Detection
'''
def HamiltonianCycle(E, n, root):
    if (cycleDetection(E, n, root)):
        return True
    else:
        return False

def matrix2table(martrix):
    result = []
    N = len(matrix)
    for i in range(N):
        tmp1 = []
        for j in range(N):
            if matrix[i][j]:
                tmp1.append(j)
        result.append(tmp1)
    return result

def table2matrix(table):
    ret = []
    N = len(table)
    for i in range(N):
        tmp = [0] * N
        for j in table[i]:
            tmp[j] = 1
        ret.append(tmp)
    return ret

if __name__ == "__main__":
    n = 2 
    k = 2
    f = 0
    G = constructGraph(n, k, 0)
    N = []
    for i in G.nodes:
        N.append(i)
    for i in G.edges:
        N.append(i)
    sum = 0
    PathLength = []
    length = 0
    for m in range(0, 1000):
        G1 = constructGraph(n, k, 0)
        Nodes = []
        for i in G1.nodes:
            Nodes.append(i)
        f = random.randrange(0, n*k-3+1)
        FaultyNodes = random.sample(N, f)
        print("Faulty Elements：", FaultyNodes)
        if len(FaultyNodes) != 0:
            for faulty in FaultyNodes:
                if faulty in Nodes:
                    G1.remove_node(str(faulty))
                    Nodes.remove(faulty)
                else:
                    faulty = str(faulty).replace("(", "")
                    faulty = str(faulty).replace(")", "")
                    N1 = faulty.split(', ')
                    N1[0] = N1[0].replace("'", "")
                    N1[1] = N1[1].replace("'", "")
                    if G1.has_edge(N1[0], N1[1]):
                        G1.remove_edge(N1[0], N1[1])
        path = []
        matrix = np.array(nx.adjacency_matrix(G1).todense())
        tb = matrix2table(matrix)
        flag = HamiltonianCycle(tb, len(Nodes), 0)
        # This path is actually a Hamiltonian cycle.
        print(path)
        if path:
            sum += 1
            print(len(path))
            PathLength.append(len(path))
            length += length + len(path)
print("The number of times to successfully find a Hamiltonian cycle is：",sum)