WO2017074417A1

WO2017074417A1 - Constrained permutation-based graph generation

Info

Publication number: WO2017074417A1
Application number: PCT/US2015/058267
Authority: WO
Inventors: Krishnamurthy Viswanathan; Fei Chen; Maria Teresa Gonzalez Diaz
Original assignee: Hewlett Packard Enterprise Development Lp
Priority date: 2015-10-30
Filing date: 2015-10-30
Publication date: 2017-05-04

Abstract

A method includes assigning a plurality of vertex sockets to vertices based at least in part on a predetermined degree distribution and assigning identifiers to the plurality of vertex sockets. The technique includes processing the assigned identifiers in a processor-based machine to permute an ordering of the identifiers and assign edges to the vertex sockets based at least in part on the permutation. The technique includes processing the assigned edges in the processor-based machine to constrain the edge assignments to prevent a predetermined structure from appearing in the graph.

Description

CONSTRAINED PERMUTATION-BASED GRAPH GENERATION

Background

[0001 ] For purposes of analyzing relatively large data sets (often called "big data"), it may be beneficial to represent the data in the form of a graphical model, or graph. For example, many real life networks, such as transportation networks, the internet, sensor networks and biological networks may be modeled using a graph.

Brief Description of the Drawings

[0002] Fig 1 is a schematic diagram of a processor-based system according to an example implementation.

[0003] Fig. 2 is an illustration of constrained permutation-based graph generation according to an example implementation.

[0004] Figs. 3 and 4 are flow diagrams depicting techniques to generate graphs according to example implementations.

[0005] Fig. 5 is a schematic diagram of a physical machine according to an example implementation.

Detailed Description

[0006] Relations among objects may be modeled using a graph. As an example, the objects may be random variables, and the graph may be used to represent the joint distribution of the random variables. In this manner, the graph may encode a factorization of the joint distribution and represent the conditional independence relationships among the random variables.

[0007] In general, graphs may be applied in any task, which involves probabilistic inference and may be used for such purposes as modeling biological networks; modeling transportation networks; malware detection; malicious domain detection; topic modeling; information extraction; web advertising and fraud detection; and modeling sensor networks, as just a few examples.

[0008] A graph has nodes, or vertices, which represent the objects and lines, or edges (also called "edge connections"), which interconnect the vertices. The edges extend between the vertices to represent relationships (conditional interdependence relationships, for example) among the vertices. In this manner, an edge may extend between a given pair of vertices to represent a relationship between the pair.

[0009] A vertex has an associated degree. For a directed graph in which the edges have associated directions, a given vertex has two degrees: an incoming degree and an outgoing degree. The incoming degree refers to the number of edge- to-vertex connections for edges directed into the vertex, and the outgoing degree refers to the number of edge-to-vertex connections of the vertex for edges directed away from the vertex. For an undirected graph in which the edges do not have associated directions, a given vertex has a single degree, which refers to the total number of edge-to-vertex connections for the vertex. In the context of this

application, the degree of a vertex refers generally to the number of edge

connections that are made with the vertex.

[0010] A relatively small graph, such as a graph that has on the order of one hundred or few vertices, may be constructed at least in part from historical data. For example, if the graph is used for malicious domain detection, the historical data may be acquired data that represents whether certain internet sites are malicious. Relatively larger graphs (a graph containing hundreds to tens of millions of vertices, for example), may be significantly more challenging to develop, based on historical data. Such relatively large graphs may be used for such purposes as testing an application that processes "big data," verifying the results provided by the

application, analyzing the application and designing the application.

[001 1 ] A relatively large graph may be synthetically generated in a manner that imparts one or multiple predetermined structural characteristics for the graph. For example, one approach to synthetically generate a graph is to specify the number of vertices for the graph, specify a degree distribution for the graph and then randomly generate the edge-to-vertex connections of the graph. In this context, the "degree distribution" of the graph refers to how the degrees are of the vertices apportioned among the vertices. Mathematically, a degree distribution P(/) of a graph may be viewed as the fraction of vertices having a degree /^'.

[0012] One way to randomly generate edge-to-vertex connections of a graph is through the use of random permutation, in this context, "permutation" refers to the arranging of an order of a collection of members (members of a set, for example) or the rearranging of the order of the members. In this random permutation approach to graph generation, a mathematical set may be defined in which the members of the set represent the edge-to-vertex connection points (called "sockets" herein) of the graph. A mapping may also be defined, which represents the socket-to-vertex mapping. This mapping and the number of members of the set (or sockets) comply with a predetermined degree distribution for the graph. The members having an associated ordering in the set, and this ordering may be used to represent edge connections among the sockets. A random permutation may be performed on the mathematical set to correspondingly randomly rearrange the ordering of the set and thus, randomly assign the edge connections for the graph.

[0013] A challenge with using the above-described random permutation-based approach to synthetically generating a graph is that such a technique may result in a graph that has relatively complex structures. For example, one such complex structure is a self-loop in which a given edge begins and terminates at sockets located on the same vertex, i.e., the given edge is connected at both ends to the same vertex. Another complex structure is one in which one or multiple parallel, or redundant, edges extend between a given pair of vertices.

[0014] In accordance with example implementations discussed herein, a graph is randomly generated using a permutation-based generation approach, which preserves a predetermined degree distribution for the graph and constrains the graph generation to inhibit predefined noncompliant graph structures (also referred to as "noncompliant structures" herein) (from appearing in the graph. For example, a "simple graph" is a graph that does not contain complex structures, such as self- loops and parallel edges, as these are considered "noncompliant," or prohibited, structures for the simple graph. As such, the simple graph contains such compliant graph structures (also referred to as "compliant structures" herein) as structures in which pairs of vertices are connected by single edges and structures in which each edge terminates on a pair of vertices.

[0015] As a more specific example, Fig. 1 depicts a processor-based system 100, which is constructed to use random permutation to synthetically generate a graph. In accordance with example implementations, the graph is a simple graph.

Moreover, In accordance with some implementations, the graph is an undirected graph, i.e., the edges of the graph are not associated with directions.

[0016] In general, the system 100 receives input data 102, which defines parameters for the graph to be generated, and the system, 100 provides output data 151 , which represents the random graph that is generated by the system 100. More specifically, in accordance with example implementations, the input data 102 includes data 104 that represents a preselected, or predetermined, degree

distribution for the random graph and data 106 that represents a preselected, or predetermined, number of vertices for the random graph. The output data 151 represents the structure of the graph, such as data 150 representing the

assignments of edges to the sockets (vertex-to-edge connections) and data 1 14 representing a mapping of the sockets to vertex identifications (IDs).

[0017] In accordance with further example implementations, the system 100 may provide data that describes less detail about the graph. For example, in accordance with example implementations, the output data 151 may merely include data that represents a list of edges, where edge is described in the data 151 by a pair of vertex IDs. This list may be constructed from the assignment of edges to sockets and the mapping of sockets to vertex IDs.

[0018] Fig. 2 illustrates a subset, or portion 200, of a graph that may be

generated by the system 100. As depicted in the portion 200, the graph, in general, contains vertices 204, which are interconnected by edges 208. Each edge 208, in turn, is associated with two edge-to-vertex connections, or sockets 206. As depicted in Fig. 2, a given vertex 204 has one or multiple sockets 206. Specific vertices 204 are described herein using numeric suffixes (vertices 204-1 and 204-2, for example).

[0019] Referring to Fig. 1 , in conjunction with Fig. 2, in accordance with example implementations, the system 100 includes a mapping engine 1 10, which, in response to the degree distribution data 104 and the vertice number data 106, generates the socket-to-vertex mapping data 1 14 and data 1 16 (called "socket ID list data 1 16" herein). The socket ID list data 1 16 represents a mathematical set, whose members are the IDs of the sockets 206 for the graph. In accordance with example

implementations, the order in which the socket IDs are arranged in the set defines the edge-to-socket connections for the graph. The system 100 assigns the IDs to the set in an initial order; and as described further herein in example implementations, the initial order and the the socket-to-vertex mapping define an initial, nonrandom graph that has the predetermined degree distribution.

[0020] A permutation engine 120 of the system 100 receives the socket ID list data 1 16 and in accordance with example implementation, applies random

permutation to the set represented by the data 1 16 to change the initial order of the set to generate permuted socket ID list data 124. Due to the permutation, the initial order changes in a random manner to correspondingly randomly change the edge- to-socket connections of the graph.

[0021 ] The permuted socket ID list data 134 and the socket-to-vertex mapping data 1 14 represent a candidate graph, i.e., a possible graph to be output by the system 100 in response to the input data 102. In accordance with example implementations, an edge assignment engine 130 of the system 100 checks the candidate graph to determine whether the graph contains certain predetermined structures (noncompliant structures for a simple graph, such as self-loops and parallel edges, for example). In this manner, in accordance with example

implementations, the edge assignment engine 130 processes the permuted socket ID list data 124 for purposes of determining whether one or multiple noncompliant structures are present in the candidate graph.

[0022] Fig. 2 depicts example predetermined noncompliant structures, which are not present in a simple graph. One of these noncompliant structures is a self-loop, which is shown by way of example in Fig. 2 by an edge 208-3 between a pair of sockets 206 that belong to the same vertex 204. As depicted by reference numeral 21 1 of Fig. 2, in accordance with example implementations, the edge assignment engine 130 may take corrective action to remove the self-loop 21 1 , as further described herein.

[0023] Fig. 2 also depicts another example noncompliant structure for a simple graph: parallel edges 208-1 and 208-2, which extend between the same pair of vertices 204-1 and 204-2. In this manner, due to the permutation by the permutation engine 120, a given pair of vertices 204-1 and 204-2 may possibly be connected by two, three, or even more edges 208. As described herein, in accordance with example implementation, the edge assignment engine 130 removes the redundant edges 208. For the specific example of Fig. 2, the edge assignment engine 130 may, in accordance with example implementations, remove the edge 208-1 , as indicated at reference numeral 209, thereby leaving a single edge 208-2.

[0024] In accordance with some implementations, the system 100 performs multiple graph generation iterations (i.e., produces a candidate graph in each iteration) until a graph is produced that does not contain one of the noncompliant structures. In this manner, as depicted in Fig. 1 , in accordance with some

implementations, the edge assignment engine 130 processes the permuted socket ID list data 124 to identify one or multiple noncompliant structures, which correspond to a set of sockets 206, whose edge connections are to be reassigned. This set of sockets 206 is represented by socket ID subset data 134. In accordance with example implementations, the permutation engine 120 performs another graph generation iteration by processing the socket ID subset data 134 to reassign the edge connections that are identified by the data 134 to regenerate, or revise, the permuted socket ID data 124. In accordance with example implementations, upon determining that no other noncompliant structures exist in the permuted socket ID list data 124, graph generation is complete, and the edge assignment engine 130 provides the output data 151 .

[0025] The above-described approach is one way to constrain (i.e., limit or restrict) the edge assignments to prevent a noncompliant structure from appearing in the generated graph. The system 100 may constrain the edge assignments in other ways to prevent noncompliant structures from appearing in the generated graph, in accordance with further example implementations. For example, in accordance with further implementations, the system 100 may not perform multiple graph iterations. In this regard, the permutation engine 120 may permute the socket IDs a single time to provide the permuted socket ID list data 124, and the edge assignment engine 130 may then process the data 124 to remove the prohibited noncompliant structures to form the final version of the graph. Although the graph may not have the predetermined degree distribution defined by the data 104, the degree

distribution may still be relatively close to the target.

[0026] As another example of an approach to constrain edge assignments to prevent noncompliant structures from appearing in the generated graph, in

accordance with further implementations, the permutation engine 120 may check, as the permutation is being performed, whether a noncompliant structure is being created; and if so, the permutation engine 120 takes corrective action to suppress the prohibited structure creation. Thus, for these example implementations, the system 100 performs a single graph generation iteration, and the permuted socket ID list data 124 after the single iteration may not contain any prohibited structures.

[0027] Referring to Fig. 3, in general, in accordance with example

implementations, a technique 300 to generate a graph includes assigning (block 304) a plurality of vertex sockets to vertices based at least in part on a

predetermined degree distribution and assigning (block 308) identifiers to the plurality of vertex sockets. Pursuant to the technique 300, the assigned identifiers are processed (block 312) to: 1 .) permute (i.e., arrange or rearrange) an ordering of the identifiers; and 2.) assign edges to the vertex sockets based on the permutation. The assigned edges are processed, pursuant to block 316, to constrain the edge assignments to prevent a predetermined structure (a noncompliant structure, for example) from appearing in the graph.

[0028] As a more specific example, in accordance with some implementations, the system 100 may perform the graph generation as follows. For this discussion, "n" represents the number of vertices of the graph to be generated, and

"n_lJ n_2J ..., ½" represents the predetermined degree distribution for the graph. In this manner, "n_£" represents the number of vertices of degree i, and "n" represents the maximum degree. Given this notation, the number of edges e in the graph may described by the following summation:

e = ¾?-i_} i * _t. Eq. 1

[0029] Referring to Figs. 1 and 2 and the notation above, in general, the system 100 may generate a graph as follows. The system 100 associates each vertex 204 of degree i with i sockets 206 from which the edges 206 incident on the vertex 204 emanate. The mapping engine 1 10 assigns socket IDs to all of the sockets 206 of the graph from the set {1,2, ... , 2e] (i.e., the initial, socket ID list) where "e" represents the number of edges, as defined above in Eq. 1 .

[0030] In accordance with example implementations, the mapping engine 1 10 assigns contiguous socket IDs to the sockets 206 on a given vertex 204. For example, for a given vertex 204 that has a degree of "5," the mapping engine 1 10 may assign, for example, socket IDs of 14, 15, 16, 17, and 18, to the sockets 206 for this vertex 204.

[0031 ] The permutation engine 120 applies random permutation to the set {1,2, ... ,2e}. This random permutation encodes which two sockets 206 are connected by the edges of the graph. For example, if socket I D=1 is mapped to socket A and socket ID=2 is mapped to socket B, then there is an edge between the vertex 204 corresponding to socket A and the vertex 204 corresponding to socket B. Likewise, if socket ID=3 is mapped to socket C and socket ID=4 is mapped to socket D, there is an edge between the vertex 204 corresponding to socket C and the vertex

corresponding to socket D. It is noted that the above-described ordered set-based edge assignment may connect two sockets on the same vertex (which forms a self- loop) or may connect two pairs of sockets on the same pair of vertices (which forms parallel edges).

[0032] Next, in accordance with example implementations, the permutation engine 120 randomly permutes the set {1,2, ... ,2e}. This permutation encodes which two sockets 206 are connected by the edges 208 of the graph, as the ordering of the permuted set defines the pairs of sockets that share an edge.

[0033] Formally, the permutation function (called "π") may be a one-to-one function defined as follows: π: {1, 2, ... , 2e}→ {1, 2, ... , 2e}. Eq. 2

The socket-to-vertex mapping may be described by a function (called "P"), which defined as follows:

P: {l, 2, ... , 2e}→{l, 2, ... , n}. Eq. 3

[0034] In accordance with some implementations, the system 100 may maintain the π and P functions in a look-up table.

[0035] In accordance with example implementations, the permutation function π is selected uniformly at random from the set of all permutations over the set

{1, 2, ... , 2e}. Given the above-defined notation, the set of all edges (called "E") resulting from the permutation may be described as follows:

E = {{Ρ{π{2 * ; - 1)), Ρ(π(2 ): 1 ≤j ≤ e}. Eq. 4.

In other words, for each pair of consecutive integers 2j - 1,2;^'), the vertex

corresponding to the socket id π(2; - 1) is connected to the vertex corresponding to the socket id π(2;^').

[0036] Generating the edge set E as described above, may introduce certain predetermined structures, which may be prohibited by certain types of graphs. For example, Ρ(π(2; - 1)) might equal Ρ(π(2;)), which corresponds to a self-loop, a noncompliant structure for a simple graph. [0037] As another example, for some j≠ k, a parallel edge, another noncompliant structure for a simple graph, may be created, as described below:

(P{n 2j - 1)), Ρ(π(2;))) = (p{n 2k - 1)), P{n 2k))). Eq. 5ln accordance with some implementations, the permutation engine 120 performs the following technique (herein called the "permutation technique), which permutes the set {1,2, ... ,2e] and removes self-loop structures. More specifically, to generate a random permutation π over 2e elements, the permutation technique creates an array A of length 2e; and 7' is an index constrained as follows: 1 < i < 2e. Also, "π(ί)" is the i-th element of the array A. The array A may be generated as described in pseudocode for the permutation technique below:

1 . Initialize A[i] = i for all entries in A

2. For j = 2e to 2

a. If is even

i. Generate a random number p, 1 < p≤ j

b. Else

i. do

1 . Generate a random number p, 1 < p≤j

ii. While P(A[p]) = P(A[j + 1])

c. Swap A[p] and A\j]

Table 1

[0038] As can be seen from Table 1 , a new random number is generated to swap elements if a self-loop would otherwise be created. More specifically, in addition to the length of the permutation 2e, the above-described permutation technique also takes the mapping P between socket IDs and their corresponding vertex IDs as input. Before assigning a value to A[j] , the permutation technique checks that the current randomly generated number does not create a self-loop structure. If that is not the case, a new random number is generated. For large graphs and where the maximum degree is small relative to the number of edges, the probability that more than one random number would to be generated will be small. Further, the expected number of random numbers that are generated is the reciprocal of the

complementary probability and is close to one.

[0039] Thus, by applying the above-described permutation technique of Table 1 , the permutation engine 120 prevents self-loops from appearing in the graph represented by the permuted socket ID list data 124. In accordance with example implementations, the above-described permutation technique may be further modified to create a permutation technique in which the engine 120 verifies whether potential parallel edges are being created and takes action to prevent these edges from being created. In this manner, in accordance with example implementations, each time a random number is generated, the permutation engine 120 may verify whether or not a parallel edge has been created in the resulting graph. In this manner, the permutation engine 120 may traverse the portions of the graph that have been created and determine if there is a parallel edge, and if so, then the permutation engine 120 does not accept the random number. Using the permutation engine 120 to preclude parallel edges as the random numbers are being generated may be particularly advantageous for regular graphs (i.e., graphs in which the nodes have the same degree) with relatively small degrees.

[0040] In accordance with further example implementations, the permutation engine 120 may not verify whether parallel edges are created during the

permutation, and the parallel edges may be subsequently removed by processing the permuted socket ID list data 124. In this manner, the permutation engine 120 may apply the above-described permutation technique without parallel edge verification to generate a set of edges for the graph (represented by the data 124), such that each edge is represented as (J, k , where < k. These edges, in turn, may include one or multiple parallel edges. Next, the system 100 (the edge assignment engine 130, for example) may sort the set of edges using the first vertex ID as the primary sort key and the second vertex ID as the secondary sort key. The system 100 may then scan the sorted list of edges and remove an edge if it is identical to the previous edge in the list, thereby removing parallel or redundant edges.

[0041 ] This approach of eliminating parallel edges after the permutation produces a graph whose degree distribution is different from the degree distribution designated by the data 104. However, as the size of the graph increases, the impact of the eliminated edges may have a relatively small effect, as a relatively small number of edges are deleted.

[0042] As another variation, in accordance with further implementations, the permutation engine 120 may perform the permutation technique without parallel edge verification, and then the edge assignment engine 130 may identify and remove the sockets that correspond to the parallel edges. This leaves a set of vertices V₁ whose actual degree is less than the predetermined degree distribution. To compensate as to corresponding loss of edges, the permutation engine 120 may perform another iteration to determine edges for the vertices V₁ In this manner, the edge assignment engine 130 may pass the vertices ^corresponding to the eliminated edges back to the permutation engine 120 (i.e., the socket ID subset data 134) to perform another graph generation iteration, as described above. The processing of the residual sockets takes less time than the number of the vertices V_{l t} as the number of vertices V , is much smaller than the number of total vertices for the graph n. Thus, one or multiple additional graph generation iterations may be performed until a candidate graph contains no parallel edges.

[0043] In accordance with further example implementations, the edge assignment engine 130 may pass the sockets corresponding to the eliminated edges (instead of just the vertices) back to the permutation engine 120. Moreover, in accordance with further example implementations, the edge assignment engine 130 may remove more edges than just the parallel or redundant edges (i.e., remove edges that are part of compliant and noncompliant structures). In this manner, the edge assignment engine 130 may pass sockets corresponding to parallel edges (i.e., edges

associated with one or multiple noncompliant structures) and sockets corresponding to a predetermined number of otherwise permitted edges (i.e., edges corresponding to one or multiple compliant structures) back to the permutation engine 120. This technique may increase the probability that the next permutation by the permutation engine 120 produces an acceptable graph.

[0044] In accordance with further example implementations, the edge assignment engine 130 may accelerate the process of assigning edges to the residual sockets by constructing and maintaining a hash table, which records the neighbors of each of the vertices 204. This approach generates a graph with a predetermined degree distribution with high probability.

[0045] Thus, referring to Fig. 4, in accordance with example implementations, a technique 400 includes assigning (block 404) a plurality of edge connections to vertices based at least in part on a predetermined degree distribution for a graph and assigning (block 408) identifiers to the edge connections. Pursuant to the technique 400, the ordering of the identifiers is randomly arranged (block 412). Based on the randomly arranged ordering, the technique 400 includes determining edges among the edge connections to generate a first representation of the graph, pursuant to block 416. A determination may then be made (decision block 420) whether the first representation contains a predetermined structure (a noncompliant structure, for example). If not, the graph generation is complete. If so, a set of edge connections associated with the predetermined structure is determined, and the first

representation is modified based on the determined set of edge connections to remove the predetermined structure to generate a second representation of the graph, pursuant to block 424.

[0046] Referring to Fig. 5 in conjunction with Fig. 1 , in accordance with some implementations, the system 100 may include a physical machine 500 that is constructed from actual machine executable instructions, or "software" 560 and actual hardware 510. The hardware 510 of the physical machine 500 may include one or multiple central processing units (CPUs) 514, a memory 518, a display 522, a network interface 520, and so forth.

[0047] In accordance with some implementations, the memory 518, in general, is a non-transitory memory, which includes non-transitory memory storage devices, such as semiconductor devices, phase change devices, random access memory (RAM) devices, dynamic RAM (DRAM) devices, resistive memory devices, flash memory devices, and combination of one or more of these devices, and so forth.

[0048] In accordance with example implementations, the machine executable instructions 560 may be stored in a non-transitory computer-readable storage medium, such as the memory 518, for example. The instructions 560, when executed by one or multiple CPUs 514, may cause the CPU(s) 514 to form the permutation engine 120, the mapping engine 1 10, the edge assignment engine 130, an operating system 570, and so forth.

[0049] The physical machine 500 may further store data 580, such as input data, output data, intermediate data, and so forth. Thus, as depicted in Fig. 5, the data 580 may include the degree distribution data 104, the permuted socket ID list data 124, the output data 150 representing the random graph, the number of vertices data 106, the socket-to-vertex mapping data 1 14, the socket I D subset data 1 16, and so forth.

[0050] As described above, one or more of the mapping engine 1 10, permutation engine 120, and edge assignment engine 130 may be formed from machine executable instructions that are executed by one or more of the CPUs 514. As such, any of these components may be a software component, i.e., a component that is formed by at least one processor/processor core executing machine executable instructions, or software. In accordance with further example implementations, one or multiple of these components may be constructed as a hardware component that is formed from dedicated hardware (one or more integrated circuits that contain logic, for example). Thus, the mapping engine 1 10, permutation engine 120 and/or edge assignment engine 130 may take on one or many different forms and may be based on software and/or hardware, depending on the particular implementation. [0051 ] Other implementations are contemplated, which are within the scope of the appended claims. For example, in accordance with further example

implementations, the system 100 may generate directed graphs. Structures other than self-loops and parallel edges may be removed by the system 100, in

accordance with further example implementations. For example, although the generation of an undirected graph is described above, in accordance with further implementations, the edge assignment engine 130, permutation engine 120, or other entity of the system 100 may constrain the graph generation to prohibit triangle structures (considered "noncompliant structures", for this example), in which three nodes and three edges form a triangle.

[0052] As another example, in accordance with further implementations, the "edges" may be "hyper edges." In this manner, a "hyper graph" is a graph structure in which an "edge" or "hyper edge," refers to any subset of vertices. In the approach outlined above, consecutive odd and even entries of the socket ID set are treated as representing the socket IDs that are connected by an edge. This may be extended to hyper graphs by designating consecutive segments of the set as corresponding to a given hyper edge.

[0053] In the context of this application, generating a "random" number means generating either a truly random number (a number derived from randomly occurring natural phenomena, such as thermal noise or antenna-generated noise, as examples) or a near random, or "pseudo random," number, which is machine generated. For example, a random number may be a generated by a seed-based generator that provides a pseudo random output. As a more specific example, the generator may be a polynomial-based generator, which provides an output that represents a pseudo random number, and the pseudo random number may be based on a seed value that serves as an input to a polynomial function. As examples, the seed value may be derived from a state or condition at the time the pseudo random number is generated, such as an input that is provided by a real time clock (RTC) value, a counter value, a register value, and so forth. In this manner, a polynomial-based generator may receive a seed value as an input, apply a polynomial function to the seed value and provide an output (digital data, for example), which represents a pseudo random number.

[0054] While the present invention has been described with respect to a limited number of embodiments, those skilled in the art, having the benefit of this disclosure, will appreciate numerous modifications and variations therefrom. It is intended that the appended claims cover all such modifications and variations as fall within the true spirit and scope of this present invention.

Claims

What is claimed is: 1 . A method comprising:

assigning a plurality of vertex sockets to vertices based at least in part on a predetermined degree distribution;

assigning identifiers to the plurality of vertex sockets;

processing the assigned identifiers in a processor-based machine to permute an ordering of the identifiers and assign edges to the vertex sockets based at least in part on the permutation; and

processing the assigned edges to constrain the edge assignments to prevent a predetermined structure from appearing in the graph.

2. The method of claim 1 , wherein assigning the edges and constraining the edge assignments comprises:

based on the permuting, determining a candidate graph substructure;

determining whether the candidate graph structure corresponds to the predetermined structure; and

based at least in part on the determination of whether the candidate graph structure corresponds to the predetermined structure, assigning the candidate graph structure to the graph.

3. The method of claim 2, wherein the candidate graph structure comprises an edge, and the predetermined structure comprises a self-loop or parallel edges.

4. The method of claim 2, wherein determining the candidate graph structure comprises determining a hyper edge.

5. The method of claim 1 , wherein constraining the edge assignments

comprises:

searching the graph after the edge assignments to identify an instance of the predetermined structure; and

correcting the graph to remove the instance.

6. The method of claim 5, further comprising:

further modifying the graph to adjust a degree distribution of the correct graph such that the degree distribution corresponds to the predetermined degree

distribution.

7. The method of claim 6, wherein further modifying the graph comprises:

determining a subset of the plurality of vertex sockets corresponding to vertices based at least in part on a predetermined degree distribution;

permuting an ordering of the identifiers associated with the subset; and assigning edges to the subset based at least in part on the permuting of the ordering of the subset.

8. An article comprising a non-transitory computer readable storage medium to store instructions that when executed by a processor-based machine cause the processor-based machine to:

assign a plurality of edge connections to vertices based at least in part on a predetermined degree distribution for a graph;

assign identifiers to the edge connections;

randomly arrange an ordering of the identifiers;

based on the randomly arranged ordering, determine edges among the edge connections to generate a first representation of the graph;

determine whether the first representation contains a predetermined structure; and

based at least in part on the determination, selectively:

determine a set of the edge connections associated with the predetermined structure; and

modify the first representation based on the determined set of edge connections to remove the predetermined structure to generate a second

representation of the graph.

9. The article of claim 8, the storage medium to store instructions that when executed by the processor-based machine cause the processor-based machine to: randomly arrange an ordering of the identifiers assigned to the set of edge connections associated with the predetermined structure; and

based at least in part on the random arranged ordering of the identifiers assigned to the set of edge connections associated with the predetermined structure, determine edges for the set of edge connections to determine a second

representation of the graph.

10. The article of claim 8, wherein the set of edge connections associated with the predetermined structure are associated with a noncompliant graph structure, and the storage medium to store instructions that when executed by the processor-based machine cause the processor-based machine to:

determine an additional set of the edge connections other than the edge connections associated with the noncompliant graph structure, the additional set of edge connections being associated with a compliant graph structure; and

modify the first representation based on the set of edge connections associated with the noncompliant graph structure and the set of additional edge connections associated with the compliant graph structure to generate the second representation of the graph.

1 1 . The article of claim 8, the storage medium to store instructions that when executed by the processor-based machine cause the processor-based machine to: represent the edges of the first representation of the graph as ordered pair of the assigned identifiers;

sort the ordered pairs to identify a redundant set of the ordered pairs; and remove the edge represented by the identified redundant set in the generation of the second representation of the graph.

12. A system comprising:

a mapping engine comprising a processor to map a plurality of vertex sockets to vertices based at least in part on a predetermined degree distribution for a graph, the vertex sockets being associated with identifiers;

a permutation engine comprising a processor to assign edges to the vertex sockets based at least in part on the permutation of a ordered list of the identifiers; and

an edge assignment engine comprising a processor to:

determine candidate edge assignments for the graph among the vertex sockets based at least in part on the permutation;

determine whether the candidate edge assignments introduce a predetermined structure; and

assign edges to the graph based at least in part on the candidate edge assignments and the determination introduce a predetermined structure.

13. The system of claim 12, wherein the predetermined structure comprises a self-loop.

14. The system of claim 12, wherein the permutation engine:

creates an ordered array representing the ordered list; and

traverses the ordered array to randomly swap the identifiers to permute the ordered list.

15. The system of claim 12, wherein the graph comprises a simple graph.