Introduction

E_b(k) is a degree-dependent network statistic used in some network-science papers to study degree correlations and scale behavior. The tricky part is that the exact normalization varies by paper, so the safest way to calculate it in Python is to translate the formula you are using into a discrete computation over degree counts and degree-degree edge frequencies.

Start by Pinning Down the Definition

Before writing code, confirm which version of E_b(k) your source uses. In practice, implementations are built from three ingredients:

• the degree distribution P(k)
• the conditional degree distribution P(k' | k)
• a threshold rule such as k' >= b k

Many implementations then compute a quantity for each degree k and study its slope on a log-log plot. So the code is less about one special NetworkX function and more about assembling the right degree statistics from the graph.

Build the Degree Statistics

The first step is to compute:

• each node's degree
• how many nodes have each degree
• how many edges connect degree k to degree k'

Here is a runnable NetworkX implementation for that setup.

1from collections import Counter, defaultdict
2import networkx as nx
3
4
5def degree_statistics(graph):
6    degrees = dict(graph.degree())
7    degree_counts = Counter(degrees.values())
8
9    edge_degree_counts = defaultdict(Counter)
10    for u, v in graph.edges():
11        du = degrees[u]
12        dv = degrees[v]
13        edge_degree_counts[du][dv] += 1
14        edge_degree_counts[dv][du] += 1
15
16    return degrees, degree_counts, edge_degree_counts
17
18
19g = nx.karate_club_graph()
20degrees, degree_counts, edge_degree_counts = degree_statistics(g)
21print(sorted(degree_counts.items())[:5])

The edge-degree count table is especially important because it lets you estimate conditional degree relationships from the observed network rather than from raw node counts alone.

A Common Discrete E_b(k) Pattern

The following function implements one common paper-style discrete pattern: for each degree k, compute a thresholded quantity based on neighbors whose degree is at least b * k.

1import numpy as np
2
3
4def ebk(graph, b=3):
5    _, degree_counts, edge_degree_counts = degree_statistics(graph)
6    node_count = graph.number_of_nodes()
7
8    pk = {k: count / node_count for k, count in degree_counts.items()}
9    result_k = []
10    result_eb = []
11
12    for k, neighbors in sorted(edge_degree_counts.items()):
13        total_edges_from_k = sum(neighbors.values())
14        if total_edges_from_k == 0:
15            continue
16
17        denominator = sum(p for degree, p in pk.items() if degree >= b * k)
18        if denominator == 0:
19            continue
20
21        numerator = 0.0
22        pk_node = pk[k]
23
24        for kp, count in neighbors.items():
25            if kp >= b * k and pk.get(kp, 0) > 0:
26                p_cond = count / total_edges_from_k
27                numerator += p_cond * (k * pk_node) / (kp * pk[kp])
28
29        if numerator > 0:
30            result_k.append(k)
31            result_eb.append(numerator / denominator)
32
33    return np.array(result_k), np.array(result_eb)
34
35
36ks, values = ebk(g, b=2)
37print(ks[:5])
38print(values[:5])

This is not the only published normalization, but it shows the implementation pattern clearly: compute degree probabilities, compute degree-conditioned edge frequencies, then evaluate the thresholded expression degree by degree.

Visualizing the Result

Once you have k values and E_b(k) values, it is common to inspect them on log-log axes.

1import matplotlib.pyplot as plt
2
3ks, values = ebk(g, b=2)
4
5plt.plot(ks, values, "o")
6plt.xscale("log")
7plt.yscale("log")
8plt.xlabel("k")
9plt.ylabel("E_b(k)")
10plt.show()

If your source paper studies a power-law relationship, the slope of this plot may be more important than the absolute vertical scale.

Why Results Can Look "Wrong"

A common source of confusion is that your plotted values may be much larger or smaller than the figure in a paper, yet the slope is still reasonable. That can happen because papers often use approximations, rescaling, or binning choices that are not fully obvious from a short formula alone.

So when validating your implementation, compare:

• the exact definition used in the paper
• whether probabilities were approximated by a power-law fit
• whether the authors log-binned the data
• whether your graph is directed or undirected

Common Pitfalls

The biggest pitfall is assuming E_b(k) has one universal definition. In practice, notation varies, so coding from the symbol name alone is risky.

Another common mistake is building degree-degree counts only in one direction for an undirected graph. If the statistic uses conditional degree probabilities, each undirected edge usually contributes to both degree perspectives.

Developers also forget that the visual slope can matter more than the absolute scale in these analyses. A vertical offset does not necessarily mean the implementation is conceptually wrong.

Summary

• 'E_b(k) is usually computed from degree probabilities and degree-degree edge statistics.'
• The exact normalization depends on the paper, so confirm the formula before coding.
• In Python, NetworkX plus Counter and edge-degree tables are enough to implement it.
• Log-log plots are often used to study the scaling behavior of E_b(k).
• Validate not just the raw values but also the slope, binning, and normalization choices used by your source.