Quantum computing device for detecting groups of interconnected nodes in a network

Abstract

Embodiments described herein relate to a quantum computing device, method and apparatus for determining inter-connected node groups in a network parameter. In one embodiment, a method comprises determining, using a quantum computing device, an initial adjacent node group based on maximizing a modularity, and detecting an inter-connected node group by grouping the initial adjacent node group based on maximizing a modularity.

Description

Technical Field

[0001] Examples of this disclosure relate to quantum computing devices that can be used to detect interconnected groups of nodes or communities in a network. Network resource allocation can be based on this detection. Background Technology

[0002] The fifth-generation (5G) telecommunications networks, designated by the 3rd Generation Partnership Project (3GPP), are being developed to provide new services and use cases for users, including people and machines or autonomous or semi-autonomous devices enabling the Internet of Things (IoT). 5G offers unprecedented speeds and flexibility, and carries more data with greater responsiveness and reliability than ever before. 5G use cases include massive machine-type communications (mMTC) and enhanced mobile broadband (eMBB).

[0003] One of the major challenges of today's increasingly complex and widespread networks is determining the patterns or structures of interconnected nodes or communities. That is, discovering groups, modules, or communities of interconnected nodes to enable optimal configuration of network resources and services. Examples of such groups or communities include industrial IoT, power grids, and healthcare networks. The number of communities at the 5G edge can become very large, making it useful to automatically detect communities and include nodes or network service users in the correct communities.

[0004] Known methods for detecting node communities include the "fast unfolding algorithm" and the "quantum walk" solution, which utilize modularity as an optimization parameter. For a given undirected graph G = (V, E) describing a network or nodes, interconnected node communities or groups are sets. To |X|.

[0005] Modularity M is a function defined as 0 to R over the set of all communities, used to compare different communities. This function can be used to analyze inter-community and intra-community connectivity and to detect communities with the highest modularity. It is a measure of the strength of dividing a network into modules, where networks with high modularity have dense clusters of connections between nodes within a module, and sparse connections between nodes in different modules or communities. Commonly used modularity functions are given by the following equation.

[0006]

[0007] Where node i is assigned to community C j Then C ij (Community Matrix) = 1

[0008] Otherwise, = 0

[0009]

[0010] m = the sum of degrees, d i = degree of node i

[0011] Vincent D. Blondel, Jean-Loup Guillaume, Renaud Lambiotte, and Etienne Lefebvre describe a "fast unfolding algorithm" in "Fast unfolding of communities in large networks" (Journal of Statistical Mechanics: Theory and Experiment, 2008(10): P10008, October 2008). This algorithm takes a graph G with N nodes as input and initializes each node with distinct communities such that each node is placed in a community ci. The algorithm then performs the following two steps until the modularity no longer increases:

[0012] Step 1: For i from 1 to N:

[0013] For j in neighbor (i):

[0014] If i is from C i If a component is removed from Cj and placed in Cj, then the modularity gain ΔM is calculated.

[0015] If ΔM is positive, node i is placed in the community with the highest ΔM. If there is no positive gain, i remains in its community.

[0016] Continue with step 1 until no further improvement in modularity can be achieved.

[0017] Step 2: Construct a new network whose nodes are the communities discovered in Step 1. The weights of the links between these new nodes are the sum of the weights of the nodes between the communities.

[0018] This method has been proven effective, and the resulting community modularity values ​​have been found to be very good. However, as the network size increases, the method becomes increasingly difficult to handle due to space and time complexity issues.

[0019] Mauro Faccin, Piotr Migdal, Tomi H. Johnson, Ville Bergholm, and Jacob D. Biamonte describe "quantum walks" in "Community detection in quantum complex networks" (Phys. Rev. X, 4:041012, October 2014). This is a classic algorithm that uses the concept of quantum walks to define an affinity function C, defined as a function from X×X to R such that C(S,T) = C(T,S) and C(S∪T,R) ≤ max[C(S,R),C(T,R)]. The algorithm also takes a graph G with N nodes as input and initializes a community set K, where each node I is assigned a separate community ci. The algorithm then performs the following process:

[0020] Execute until |K| = 1

[0021]

[0022] Calculate C(A,B).

[0023] In this model, the largest communities A and B of C are merged. This affinity function can be used to construct a dendrogram through aggregate clustering, starting with each node in a different community and ending with each node in the same community. At each level, modularity is calculated to determine the community with the optimal modularity.

[0024] The algorithm is good at discovering new communities in the process, although it is computationally intensive and may be difficult to scale to large networks. Summary of the Invention

[0025] One object of this disclosure is to provide an improved method and apparatus for detecting groups of communication nodes in a network.

[0026] In one aspect, a method is provided for detecting interconnected node groups in a network using a quantum computing device. The method includes: determining an initial group of neighboring nodes based on maximizing modularity using the quantum computing device; and detecting interconnected node groups by grouping the initial group of neighboring nodes determined based on maximizing modularity.

[0027] This allows for the easy and rapid detection of interconnected network node groups, thus enabling a more scalable approach to analyzing large and complex networks. For example, interconnected node groups can be detected in telecommunications networks, and automatically allocated network resources increase resilience where appropriate and reduce unwanted loading effects such as latency and connection loss.

[0028] In one embodiment, detecting interconnected node groups includes grouping a determined initial group of adjacent nodes, wherein the modularity is increased. The determined initial group of nodes may be iteratively grouped until the modularity no longer increases.

[0029] In one embodiment, the quantum computing device includes a quantum circuit with one or more oracles coupled to registers associated with nodes of the network and an initial group of neighboring nodes for each node.

[0030] In another aspect, an apparatus for detecting interconnected node groups in a network is provided. The apparatus includes a processor and a memory containing instructions executable by the processor, thereby enabling the apparatus to: determine an initial group of neighboring nodes based on maximizing modularity using a quantum computing device. The processor is also operable to: detect interconnected node groups by grouping the initial group of neighboring nodes determined based on maximizing modularity.

[0031] According to specific embodiments described herein, a computer program including instructions is also provided that, when executed on a processor, causes the processor to perform the methods described herein. Attached Figure Description

[0032] To better understand the examples of this disclosure, and to more clearly illustrate how the examples can be implemented, reference will now be made to the following figures only by way of example, wherein:

[0033] Figure 1 An example of a network with interconnected groups of nodes is shown;

[0034] Figure 2 A device for detecting interconnected node groups is shown;

[0035] Figure 3 A quantum circuit for determining adjacent network node groups that maximize modularity is shown.

[0036] Figure 4 This is a flowchart illustrating an example of a method for detecting interconnected network node groups using increased modularity. Detailed Implementation

[0037] For purposes of explanation and not limitation, specific details, such as particular embodiments or examples, are set forth below. Those skilled in the art will understand that other examples may be employed in addition to these specific details. In some cases, detailed descriptions of well-known methods, nodes, interfaces, circuits, and devices have been omitted to avoid unnecessary ambiguity. Those skilled in the art will understand that the described functions can be implemented in one or more nodes using hardware circuitry (e.g., analog and / or discrete logic gates, ASICs, PLAs, etc., interconnected to perform dedicated functions) and / or using software programs and data combined with one or more digital microprocessors or general-purpose computers. Nodes communicating using an air interface also have suitable radio communication circuitry. Furthermore, where appropriate, the technology may also be considered to be entirely contained within any form of computer-readable storage, such as solid-state memory, disk, or optical disk, containing a suitable set of computer instructions that will cause a processor to execute the technology described herein.

[0038] The hardware implementation may include, but is not limited to, digital signal processor (DSP) hardware; reduced instruction set processors; hardware (e.g., digital or analog) circuitry, including but not limited to application-specific integrated circuits (ASICs) and / or field-programmable gate arrays (FPGAs); and (where appropriate) state machines capable of performing such functions.

[0039] The embodiments relate to network analysis and network resource configuration using modularity to detect interconnected network node groups. Identifying such groups can be used for a variety of purposes, including allocating additional network resources within the group to ensure adequate capacity. Known methods for detecting network node groups do not scale well with the number of nodes and may therefore be ineffective for analyzing and optimally configuring emerging 5G networks.

[0040] Figure 1 A communication network 100, such as a 5G network, with multiple nodes 110 is illustrated. Nodes 110 have connections or links 120 with other neighboring nodes. Interconnected node groups 130 can be detected, with high-density connections between nodes in group 130 but relatively few connections 120 with other groups 130. Detecting these groups within the communication network allows for optimization of specific configurations or parameters of the network 100. For example, connections between node groups 130 can be made more robust by increasing redundancy, since there are fewer connection paths between nodes in different groups compared to nodes within the same group.

[0041] Quantum computers (QC) promise to be a new form of computing, fundamentally different from previous “classical” computing. While QCs are technically more difficult to build, and the best current general-purpose quantum computers only have 50-100 qubits, they can solve problems where time grows much more slowly with the input size, and are therefore suitable for analyzing large networks where the computational cost and / or time required for classical computation can be daunting.

[0042] In this specification, the term "quantum computing device" may include quantum circuits, which are quantum computing models executed on classical computing devices to simulate quantum algorithms implicit in the quantum circuits.

[0043] The term "qubit" refers to a quantum two-dimensional system, such as the spin of a half-spin particle. A qubit can be considered a generalization of a classical bit (cbit) because a classical bit can be in either state 0 or 1, while the state of a single qubit is determined by |α|. x 2 |+|β x 2 The complex number α = 1 x and β x To describe it. A qubit is a state in a complex vector space of dimension 2. Based on the standard, it can be represented as... Where |α x 2 |+|β x 2 |=1. If α=1. x =0 or β x If |=0, then the bit is equivalent to a classical bit. Otherwise, a qubit is said to be a superposition of |0> and |1>.

[0044] A register is a composite system of qubits, in which qubits exist in a dimension of 2. n A system with n qubits is defined in a complex vector space. This is given by the tensor product of n complex vector spaces of dimension 2.

[0045] A finite-dimensional Hilbert space H is a finite-dimensional vector space with defined inner products. In quantum computing and quantum information, a state is defined as a positive semi-definite matrix ρ with tr(ρ) = 1. A pure state is a rank-1 state, which can be represented as its eigenvectors. So that A mixed state is a state with rank > 1. In this case, the state can be represented as a convex sum of the pure states using spectral decomposition. The matrix representation of the state is called the density matrix.

[0046] A qubit changes its state by undergoing one or more unitary transformations. A unitary matrix or gate is a matrix U∈B(H), where B(H) is the set of all matrices over H such that UU*=U*U=I. An example is the Hadamard gate described by the following unitary matrix:

[0047] Measurement corresponds to transforming quantum information stored in a quantum system into classical information, such that, for example, the output of a register with n qubits contains 2... n One of the values, for example, a register with 20 qubits has 4,294,967,296 available values, and the measurement will output one of these values. The measurement is determined by the set of measurement operators M = {M i Defined by} so that

[0048]

[0049] During the measurement process, the probability of seeing result i is:

[0050]

[0051] The measured state is given by the following formula.

[0052]

[0053] For the density matrix ρ, the probability of seeing result i is

[0054] P(i)=tr(M i * M i ρ),

[0055] The measured state is given by the following formula.

[0056]

[0057] The power of quantum computers comes from their scalability. A system with n classical bits (cbits) can be in 2^n different states, while the states of n qubits can be categorized by length 2^n. n These are described by complex unit vectors. These vectors (also called wave vectors or wave functions) can be transformed by multiplying them by a unitary matrix. For example, an O(n) time complexity can be used. 2 A number of fundamental quantum gates perform Fourier transforms on the wave vector. However, not all transforms can be performed efficiently. The quantum measurement law also limits the amount of information that can be extracted from a quantum state. A complete measurement of the state produces a result x, where the probability of destroying the state in the process is |α|. x | 2Therefore, although describing a quantum state with n qubits requires an amount of information that expands exponentially with n, measurements can only extract n bits of information. Despite this and other limitations, finding a way to benefit from the exponential state space of a quantum computer is a core challenge in writing new quantum algorithms.

[0058] One embodiment uses a hybrid system of quantum and classical computing to detect groups of interconnected nodes. To implement a quantum computing device or quantum circuit, the problem of detecting groups of interconnected network nodes needs to be appropriately defined, as described in more detail below. This can be achieved using a quantum oracle that takes a graph as input to discover initial neighboring node groups by maximizing modularity. The classical computing portion of this embodiment can then traverse various combinations or groups of nodes, starting from the initial neighboring node group, until no further improvement in modularity is achieved. The resulting interconnected node groups can then be used as the basis for configuring various network setups.

[0059] Figure 2 An apparatus for detecting an interconnected network of nodes is illustrated according to one embodiment. The apparatus includes a classical computer 200 and a quantum computing device 230. The classical computer 200 may be arranged to control the operation of the quantum computing device 230 and / or receive and further process measurement outputs from the quantum computing device. The computer 200 may be configured in a cloud environment capable of communicating with the quantum computing device 230, or the computer 200 may be integrated with the quantum computing device 230 at close physical proximity. In an alternative arrangement, the computer may use, for example, quantum circuitry to emulate the quantum computing device 230.

[0060] Apparatus 200 includes processing circuitry 210 (e.g., a processor) and memory 220 in communication with the processing circuitry 210. Memory 220 contains instructions 225 that, when executed by processor 210, cause the processor to perform the methods of the embodiments. Memory 220 can also be used to store values ​​and / or measurements. An example method is shown that can be executed by apparatus 200 to detect groups of interconnected nodes in a network.

[0061] At 250, the method controls a quantum computing device 230 to determine an initial group of neighboring nodes based on maximizing modularity. The quantum computing device includes a quantum circuit that runs multiple times to determine these initial groups that can be stored in memory 220. The number of runs is significantly reduced compared to applying classical computing methods to this step. An example quantum circuit is described in more detail below.

[0062] In 255, computer 200 uses these initial neighboring node groups to detect one or more interconnected node groups based on maximizing modularity. This is achieved by combining initial neighboring node groups until a combined group is found where no further combination increases modularity. For example, multiple pairs of initial neighboring node groups can be combined, and initial neighboring node groups with increasing modularity are combined with other initial or paired neighboring node groups. This process of combining increasingly larger node groups continues until the combined groups have the maximum modularity; in other words, they cannot be combined with any other node group to increase modularity. An example algorithm is described in more detail below.

[0063] A communication network can be modeled as an undirected, unweighted graph G, which is a mathematical structure used to model the pairwise relationships between nodes. This graph defines vertices V (network nodes) and edges E (connections between adjacent nodes) and can be described in matrix format. The adjacency matrix A of the graph G or network is determined by indicating which pairs of vertices are adjacent or connected by edges E in a square matrix of vertices V.

[0064] A network node graph G = (V, E) (|V| = N) can be divided into r initial groups or communities. Assume X = {P} j}, where initially each group has only one node. The function T makes T X (P i ,P j ) can be used to represent the community P i and P j The difference in modularity before and after merging into a single community (where i ≠ j). That is, where X = {P1, P2, ..., P...} r}, then X' = (X / {P i ,P j})∪({P i ∪P j}), where X' is a group P i and P j The combination of . Then, T X (P i ,P j ) = M(X') - M(X).

[0065] Using the previously mentioned modularity function M, where Matrix B is Where A is the adjacency matrix, d i Let be the degree of node i, and m be the sum of the degrees. Suppose C is the community matrix associated with X, and C[k] is the k-th column of C, which represents community P. k .Then,

[0066]

[0067] X' corresponds to the merged community or group P. i And P. Then, C' is the community matrix associated with X'. Suppose Y is the column set of C, and Y' is the column set of C'. It can be seen that Y' = (Y / {C[i],C[j]})∪({C[i]+C[j]}).

[0068] Assuming C'[k0] is a unique column in Y' / Y, then C'[k0] = C[i] + C[j]. Therefore:

[0069]

[0070] (Because B is a real symmetric matrix)

[0071] It can be seen that T X (P i ,P j ) = T X (P j ,P i ).

[0072] Suppose I = {l|C[i]} l =1} and J = {l|C[j]} l =1}, where C[i] l C[j] l It is the l-th coordinate of C[i] and C[j]. Because in paired disjoint partitions, a node cannot be part of two communities. Then,

[0073]

[0074] Initially, each node is considered to be in a separate community or group. This means that the division into communities is given as X = {P} i}, where P i ={i}, i∈V.

[0075] Then, we hope to discover adjacent node groups by maximizing the modularity. For each node i, this can be done using G(i) = argmax. j≠i T X (P i ,P j To determine this. For each community P i P G(i) It was with P i The community with the highest modularity gain when grouped or merged together. Assume j 0 =argmax j T X (PG(j) ,P j If P is combined or merged, then P is merged or merged. G(j 0 ) and P j 0 maximizes modularity.

[0076] From this point onward, after each merge, at each step, we determine the next merge that will maximize modularity. For each community, besides newly created communities, we know which other community provides the highest modularity at the time of the merge.

[0077] At any given moment, suppose there are r communities or groups in the network. That is, X = {P} j}, so that the total number of non-empty elements in X is r. P j 0 It does not need to be a singleton set. For each community P j , will P G(j) It is considered a community that maximizes modularity after the merger.

[0078] Then, assume H(j) = T X (P G(j) ,P j Where H represents that P can be used to... j The best possible modularity gain obtained by merging with any community. Assume P k This is the community formed after the next merger, and it is assumed that the new partition is X. 0 That is, P k =P i ∪P j Consider i0≠i and j0≠j. To determine if in merging P... i and P j Before and after merging P i0 and P j0 What is the change in modularity? Assume C and C' are the community matrices before and after the merge. In the merge P... i and P j Before,

[0079]

[0080] In the merger P i and P j after,

[0081]

[0082] However, C'[i0] = C[i0] and C'[j0] = C[j0], which means that at any step, in order to find the next optimal merge, for each community, we can calculate the change in modularity between that community and the newly formed community. That is, for each community P l ,

[0083] H(l):=T(P k ,P l If T(P) k ,P l )≥H(l)

[0084] This means that if the information of H(l)' from the previous step is available, the entire maximum value discovery process is not required.

[0085] The algorithm based on the above derivation is shown below:

[0086] Input: Graph G = (V, E) (|V| = N) and its adjacency matrix A.

[0087] Output: Community partitions of the graph

[0088] –Step 1: Initialize X = {P} i}, where for all i, P i ={i} and H(i)=0

[0089] – Step 2: For each i, execute:

[0090] *G(i)=argmax j≠i T X (P i ,P j )

[0091] *H(i)=T X (P G(i) ,P i )

[0092] –Step 3: Assume j0 = argmax i T(P G(i) ,P i ). Set P j0 =P j0 ∪P G(j0) ,Then And H(G(j0))=0

[0093] –Step 4: Continue executing until…

[0094] For each i, where Set G(i) = j0 and H(i) = T(P) i ,Pj0 If H(i)≤T X (P i ,P j0 )

[0095] *j0=argmaxi(H(i))

[0096] *Set Pj0 = Pj0∪P G(j0) ,Then And H(G(j0))=0

[0097] *If for any i, where G(i) = G(j0), then G(i) = j0 and H(i) = TX(P) i ,P j0 )

[0098] Step 5: Return to P i '

[0099] Step 2 of the algorithm described above determines the initial neighboring node groups based on maximizing modularity. Each node is initially assigned to its own group or community and is then combined with neighboring nodes to form new combined groups or communities, where this results in higher modularity. If such merging or grouping does not result in higher modularity, the neighboring node remains in its own community or group. Upon merging, the new group is then again combined or merged with neighboring nodes, provided that this results in higher modularity. This iterative process continues until an initial neighboring node group is determined for each node. This process can be computationally intensive, especially as the number of nodes in the network increases quadratically.

[0100] In one embodiment, the quantum circuit can be designed to implement the algorithm described above using a quantum computing device. Then, the initial neighboring node group with the highest modularity can be found in O(√N) operations instead of O(N) operations.

[0101] Consider an undirected, unweighted graph G = (V, E), where initially each node is in its own separate community. The partitioning into communities is then given as follows:

[0102] X = {P} i}, where P i ={i}, i∈V.

[0103] Suppose N = |V|, and for simplicity, assume that for some integer n, N = 2. n If not, additional nodes may not be connected to other edges E, making it an exponent of 2. Each community is represented by a basis vector |i>. Now consider the oracle:

[0104] f(|i,j>,|l,m>)=1 if T X (|i,j>)≥T X (|l,m>)

[0105] =0 Other cases

[0106] The goal is to identify, for each community |i>, the community |j> that maximizes modularity during merging. This is equivalent to determining...

[0107]

[0108] The maximum value can be determined using the Durr Hoyer algorithm. This is described, for example, in "Community detection in quantum complex networks" (Phys. Rev. X, 4:041012, October 2014) by Mauro Faccin, Piotr Migdal, Tomi H. Johnson, Ville Bergholm, and Jacob D. Biamonte, mentioned above. However, in one embodiment, this can be discovered using an oracle f, where the algorithm is:

[0109] For each i, execute

[0110] – Initialize y = y0 randomly starting from 0 ≤ y ≤ N–1.

[0111] – Repeat the steps below Second-rate

[0112] *Initialization state

[0113] * Use oracles to apply Grover search.

[0114] *Observe the first register. If |i,j0> is the result, and if T(|i,j0>)≥T(|i,y0>), then set y0=j0.

[0115] – Return y0

[0116] – Set G(i) = y0

[0117] In one example, two oracles can be used:

[0118] A:|i,j,z>→|i,j,z+A[i,j]>

[0119] D:|i,j,z>→|i,j,zD[i,j]>

[0120] Here, D is a matrix, and its entries are given as follows:

[0121] The modified modularity function M' is M'(X)=tr(C T (AD)C) is given because it works in the same way as the previous modularity function used for different partitions of the same graph. We can use this when comparing the modularity of different community partitions of the same graph because the modularity function used is the same for any partition X.

[0122] Using M', the modified module degree change function T X '(P i ,P j ) = M'(X') – M'(X). T X '(P i ,P J )=Σ l0∈I,l1∈J (A l0l1 -D l0l1 In step 2, each node is a community, and therefore each community is a single-element set. This means that the operator AD:|i,j,z>→|i,j,z+A[i,j]-D[i,j]> can be used for T'|i,j>

[0123] Use the unit operator

[0124] U|i>|j>|0>=|i>|j>|1>, if i≥j

[0125] =|i>|j>|0>, other cases

[0126] The combination of AD with U and Z gates is oracle f.

[0127] An oracle f can be implemented using 7 registers as follows.

[0128] ·

[0129] ·

[0130]

[0131] ·

[0132]

[0133] ·

[0134] If A ij -D ij ≥A kl-D kl

[0135] =|i>|j>|A ij -D ij >|k>|l>|A kl -D kl >|0>, other cases

[0136] Here, U 367 Z1 is a U-gate applied to registers 3, 6, and 7, and Z7 is a Z-gate applied to register 7. In terms of space complexity, we need d qubits to store the value in register 3 or register 6. Then, we need 4n + 2d + 1 qubits to run the circuit. The circuit is run in O(...). N1.5 This process is repeated to determine the initial group of adjacent nodes. This corresponds to step 2 mentioned above, and once completed, the remainder of the algorithm can be executed using classical computing equipment. However, for these subsequent steps, the embodiment uses functions M' and T' instead of M and T.

[0137] Assumption definition Then, in Figure 3 The final quantum circuit that implements the above operations is shown in the figure.

[0138] Figure 3 A quantum circuit according to one embodiment is illustrated. The quantum circuit can be implemented in a quantum computing device and controlled and measured using classical computing devices to form a hybrid computing system. The quantum computing device can be implemented as a quantum computer that manipulates subatomic particles, or it can be implemented as a quantum algorithm simulated on a classical computing device.

[0139] The quantum circuit 300 includes seven registers 310 (numbered in descending order), each containing multiple qubits depending on the number of nodes. The classical computing device initializes the registers as described above. Registers 1, 2, and 3 contain a superposition of all communities, while registers 4, 5, and 6 contain the communities for which we are trying to find the best community for grouping or merging. Register 7 is used to implement multiple oracles. The qubits of the second register are superimposed using a Hadamard gate 315. Registers 1, 2, and 3 are fed into the first AD oracle 320, and registers 4, 5, and 6 are fed into the second AD register 325. The seventh register is an auxiliary register with a unitary gate 330 based on the outputs of the oracles from registers 3 and 6. The unitary gate 330 is coupled to a Z-gate 335. The outputs of the second register's oracle 320 are coupled to another Hadamard gate 340, a V-gate 345 (see V as defined above), and another Hadamard gate 350. This combination of gates provides a reflection of the equal superposition state. Finally, the measurement gate 355 measures the output from each run of the circuit.

[0140] Once the quantum circuit 300 has been run a predetermined number of times, the values ​​from the measurement gate 350 can be analyzed, for example, to detect interconnected node groups based on maximizing modularity. The quantum circuit 300 has community or node inputs, and its output is either the optimal grouping community or the optimal merging community. The optimal merging community of each node can then be optimally used as the starting point for classical algorithms to detect interconnected node groups based on maximizing modularity.

[0141] In terms of complexity, in the worst case, if N is even, then calculating T... X (P i ,P J The required number of steps can be If N is odd, then it is In step 2 above, the function T is calculated NC² times, i.e., O(N 2 Then, in each iteration, T is calculated O(N) times, and in the worst case, it will require N-1 merges.

[0142] Using the quantum circuit described above to perform step 2, T is calculated to be O(N). 1.5 The computational complexity T in the entire step 2 is [number] times. X It is constant.

[0143] In comparison, in the fast unfolding algorithm, step 1 requires O(m) steps, where m is the number of edges in the network. This is repeated until no further improvement in modularity is achieved, then the unfolding process is performed and step 1 is executed again. This can be intractable on some very large and dense datasets. The algorithm in this embodiment is less affected by the number of edges and can be used for large, dense networks thanks to the proposed quantum speedup.

[0144] This embodiment is simulated on two popular datasets used to measure the quality of the community detection algorithm: (1) the Zachary Karate Club dataset and (2) the U.S. College Soccer dataset.

[0145] Zachary's karate club is a social network of university karate clubs, described in Wayne W. Zachary's paper "An Information Flow Model for Conflict and Fission in Small Groups." This network has become a popular example of community structure in online networks.

[0146] Dataset Zachary Karate Club American soccer Number of nodes 34 115 Number of sides 78 613 Modularity score 0.3784 0.5152 Number of communities detected 3 5

[0147] The communities selected for the karate club dataset are:

[0148]

[0149] The communities selected for the US college soccer dataset are:

[0150]

[0151] To run step 2 of the proposed algorithm using quantum computing, the Karate Club dataset requires 25+2d qubits and the US Soccer dataset requires 29+2d qubits, where d depends on the number of decimal places used to store the real values ​​from the oracle's output.

[0152] Figure 4 A method 400 for detecting interconnected node groups in a network based on modularity is illustrated. This method can be executed using a combination of classical and quantum computing devices, such as… Figure 2 The system and Figure 1 This method can be implemented in classic computers and / or using different types of networks, although it can be used in networks.

[0153] In step 405, method 400 determines the adjacency matrix of network 100. If node i is connected to node j, then the adjacency matrix A = [a ijIf the adjacency matrix is ​​1, then it is 0 otherwise. Any suitable method for determining the adjacency matrix of a node network can be used.

[0154] Method 400 utilizes two iterative loops to determine the initial adjacent node group and detect the interconnected node group, respectively. Both loops are based on maximizing the modularity function (e.g., M as previously described). In step 410, the parameters of the initial iterative loop are initialized. Here, for all i (where i is the node index), X = {P} i}, where P i ={i} and H(i)=0.

[0155] In step 415, method 400 determines the initial neighboring node group for each node, adding neighboring nodes to groups in which the modularity increases to a positive value. For example, starting with node x in its own node group, the iterative loop forms larger groups including neighboring nodes, provided that this operation increases the modularity. Then, the loop forms larger groups including nodes adjacent to the merged group, provided that this increases the modularity, and so on, until the modularity no longer increases. At this point, the initial neighboring node group for node x is determined, and the iterative loop moves to other starting nodes to determine the initial neighboring node group for each node in the other starting nodes. This can be represented using the function H(i) = T X (P G(i) ,P i For each node, find G(i) = argmax j≠ i T X (P i ,P j This is to determine whether the modularity increases during each merge as described above.

[0156] Step 415 can be used, for example, for... Figure 3 The quantum circuit described is used to implement this. This can be achieved using a quantum oracle as previously described, although alternative implementations can use Hamiltonian simulations to determine other suitable quantum circuits.

[0157] Once an initial group of neighboring nodes is found for each node in the network, method 400 moves to step 420, where the parameters of the second iteration loop are initialized. This set is set to j0 = argmax. i T(P G(i) ,P i ), P j0 =P j0 ∪P G(j0) as well as And H(G(j0)) = 0.

[0158] In step 425, method 400 determines whether there is a next initial adjacent node group to be merged, and if so, proceeds to step 430. Otherwise, once all initial groups have been processed by the second loop below, the method moves to step 445.

[0159] In step 430, method 400 detects interconnected node groups by merging initial neighboring node groups and the resulting merged node groups until the modularity no longer increases. For example, starting with the initial neighboring node group determined for node x, the method determines whether merging this initial neighboring node group with the initial neighboring nodes of node y will increase the modularity, and if so, merges the two groups to form a larger merged group. Then, the method determines whether merging this larger merged group with another initial neighboring node will increase the modularity. If yes (435 "Yes"), the method moves to step 440; otherwise (435 "No"), the method returns to step 425 to process the next initial neighboring node group.

[0160] In step 440, method 400 groups or merges these groups to form supergroups. Larger supergroups can be formed by further merging with other initial neighboring node groups, other merged groups, and supergroups, until further merging no longer results in any increase in modularity. This process is repeated starting from each initial neighboring node group determined according to step 415. This can be represented as finding j0 = argmax for each node i. i (H(i)), where G(i) = j0 and H(i) = T(P) i ,P j0 The premise is that H(i)≤T X (P i ,P j0 ).

[0161] In step 445, method 400 has considered all nodes and returned the detected interconnected node groups. The output of this method can be a series of node groups. These node groups can then be used to reconfigure the network, such as adding redundancy to some connections, increasing bandwidth for some connections, while reducing bandwidth for others, etc.

[0162] The embodiments offer several advantages, including faster detection of interconnected network node groups and greater scalability for large and / or dense, complex networks. Network modularity can be optimized in a short time, and the embodiments provide good estimation of interconnected node groups. Once communities are detected, the characteristics of these communities, such as the most influential nodes, can be determined.

[0163] As networks grow larger, classical computing methods reach practical limits, while quantum computing methods, as exemplified, scale more slowly in terms of required gates and qubits, and are therefore capable of handling large, heterogeneous networks such as 5G telecommunications networks. This ability to handle such large, complex, and heterogeneous networks allows for more efficient and effective use and allocation of resources within the network.

[0164] It should be noted that the examples above are illustrative and not limiting of the invention, and those skilled in the art will be able to devise many alternative examples without departing from the scope of the appended statements. The word “comprising” does not exclude the presence of elements and steps other than those listed in the claims or embodiments, and “a” or “an” does not exclude a plurality, and a single processor or other unit may perform the functions of the plurality of units listed in the following statements. When using the terms “first,” “second,” etc., they should be understood only as labels that facilitate the identification of specific features. In particular, unless expressly stated otherwise, they should not be construed as describing a first or second feature among a plurality of such features (i.e., a first or second feature among such features occurring in time or space). Unless expressly stated otherwise, the steps in the methods disclosed herein may be performed in any order. Any reference symbols in the statements are not to be construed as limiting the scope of the statements.

Claims

1. A method for detecting interconnected groups of nodes in a communication network using a quantum computing device, the method comprising: The quantum computing device is used to determine an initial neighboring node group based on maximizing modularity. The quantum computing device includes a quantum circuit comprising: a first oracle and a second oracle, each having a first matrix; and seven registers, wherein a first, second, and third register represent nodes of the communication network and are coupled to the first oracle; a fourth, fifth, and sixth register represent the initial neighboring node group and are coupled to the second oracle; a seventh register is coupled to a U-gate, which is coupled to a Z-gate; wherein the first matrix is ​​used to interact with the first, second, and third registers, as well as with the fourth, fifth, and sixth registers, to maximize modularity. Interconnected node groups are detected by merging initial adjacent node groups determined to maximize modularity; and Configure the resources of the communication network based on the detected interconnected node groups; The determination includes: applying the first oracle to the first register, the second register, and the third register; applying the second oracle to the fourth register, the fifth register, and the sixth register; and using the U gate to combine the outputs of the first oracle and the second oracle.

2. The method according to claim 1, wherein, The detection of the interconnected node group includes: merging the determined initial adjacent node groups, wherein the modularity of the merged adjacent node groups is increased.

3. The method according to claim 2, wherein, Detecting the interconnected node group further includes: iteratively merging the determined initial adjacent node groups until the modularity of the merged adjacent node groups no longer increases.

4. The method according to claim 1, wherein, The first matrix includes the adjacency matrix of the communication network and a second matrix that depends on the degree of the nodes in the communication network.

5. The method according to any one of claims 1 to 4, wherein, Determining the initial neighbor group includes: for each node i in the communication network, using G(i) = argmax j≠i T X (P i ,P j ) to determine the initial neighboring node group of node i, where P i P represents the node group with index i. j T represents the node group with index j. X (P i ,P j ) indicates that in the node group P i and P j The change in modularity before and after the merger, wherein the change in modularity is positive.

6. The method according to claim 5, wherein, Using the quantum computing device includes running the quantum circuit √N times, where N is the number of nodes in the communication network.

7. An apparatus for detecting an interconnected group of nodes in a communication network, the apparatus comprising a processor and a memory, the memory containing instructions executable by the processor to enable the apparatus to: The initial neighbor group is determined using quantum computing devices based on maximizing modularity. The quantum computing device includes a quantum circuit, which includes: a first oracle and a second oracle, each having a first matrix; and seven registers, wherein the first, second, and third registers represent nodes of the communication network and are coupled to the first oracle, the fourth, fifth, and sixth registers represent the initial adjacent node group and are coupled to the second oracle, and the seventh register is coupled to a U-gate, which is coupled to a Z-gate, wherein the first matrix is ​​used to interact with the first, second, and third registers and with the fourth, fifth, and sixth registers to maximize modularity; Interconnected node groups are detected by merging initial adjacent node groups determined to maximize modularity; and Configure the resources of the communication network based on the detected interconnected node groups; The determination includes: applying the first oracle to the first register, the second register, and the third register; applying the second oracle to the fourth register, the fifth register, and the sixth register; and using the U gate to combine the outputs of the first oracle and the second oracle.

8. The apparatus of claim 7, operable to detect the interconnect node group, comprises: The initial adjacent node groups are merged, and the modularity of the merged adjacent node groups is increased.

9. The apparatus of claim 8, operable to detect the interconnect node group, further comprises: The initial node groups are iteratively merged until the modularity of the merged adjacent node groups no longer increases.

10. The apparatus according to claim 7, wherein, The first matrix includes the adjacency matrix of the communication network and a second matrix that depends on the degree of the nodes in the communication network.

11. The apparatus according to claim 7, wherein, The quantum circuit also includes a measurement gate coupled to one of the first register, the second register, and the third register.

12. The apparatus according to any one of claims 7 to 11, operable to determine the initial group of adjacent nodes includes: For each node i in the communication network, use G(i) = argmax j≠i T X (P i ,P j ) to determine the initial neighboring node group of node i, where P i P represents the node group with index i. j T represents the node group with index j. X (P i ,P j ) indicates that in the node group P i and P j The change in modularity before and after the merger, wherein the change in modularity is positive.

13. The apparatus of claim 12, operable to use the quantum computing device, comprises: The quantum circuit is run √N times, where N is the number of nodes in the communication network.

14. A computer program product comprising a non-transitory computer-readable medium storing a computer program comprising instructions which, when executed on at least one processor, cause the at least one processor to perform the method according to any one of claims 1 to 6.

Images