What is quantum computing?

Quantum computing is a new approach to calculation that uses principles of fundamental physics to solve extremely complex problems very quickly.

lFip a coin. Heads or tails, right? Sure, once we see how the coin lands. But while the coin is still spinning in the air, it’s neither heads nor tails. It’s some probability of both.

This gray area is the simplified foundation of quantum computing.

Digital computers have been making it easier for us to process information for decades. But quantum computers are poised to take computing to a whole new level. Quantum computers represent a completely new approach to computing. They have the potential to solve very complex statistical problems that are beyond the limits of today’s computers. Quantum computing has so much promise and momentum that McKinsey has identified it as one of the next big trends in tech. Quantum computing alone—just one of three main areas of emerging quantum technology—could account for nearly $1.3 trillion in value by 2035. Investors of all kinds are perking up their ears—and opening up their wallets: government investors alone have pledged $34 billion in investments. In 2022, the US government announced $1.8 billion in funding, bringing its total investment to $3.7 billion.

How does a quantum computer work?

Here’s how quantum computing works: classical computing, the technology that powers your laptop and smartphone, is built on bits. A bit is a unit of information that can store either a zero or a one. By contrast, quantum computing is built on quantum bits, or qubits, which can store zeros and ones. Qubits can represent any combination of both zero and one simultaneously—this is called superposition, and it is a basic feature of any quantum state. Chips are the physical hardware that store qubits, just like in classical computing.

When a classical computer solves a problem with multiple variables, it must conduct a new calculation every time a variable changes. Each calculation is a single path to a single result. Quantum computers, however, can explore many paths in parallel through superposition.

Additionally, qubits can interact with one another. This is known as entanglement. Entanglement allows qubits to scale exponentially; two qubits, for example, can store and process four bits of information, three can process eight, and so on. This exponential scaling gives the quantum computer much more power than classical computers.

Heavyweight tech organizations are already placing bets on quantum technology. In 2019, Google claimed that its quantum computer had solved in just 200 seconds a problem that would have taken a classical computer 10,000 years (although other tech organizations and academics have surfaced doubts about the validity of Google’s claim).

Even if Google’s claim was accurate, the achievement was more of a theoretical leap forward than a practical one since the problem its quantum computer solved had no real-world use. But we’re rapidly approaching a time when quantum computers will have a real impact on our lives.

What are quantum computers used for?

Today’s classical computers are relatively straightforward. They work with a limited set of inputs and use an algorithm and spit out an answer—and the bits that encode the inputs do not share information about one another. Quantum computers are different. For one thing, when data are input into the qubits, the qubits interact with other qubits, allowing for many different calculations to be done simultaneously. This is why quantum computers are able to work so much faster than classical computers. But that’s not the end of the story: quantum computers don’t deliver just one clear answer like classical computers do; rather, they deliver a range of possible answers.

For calculations that are limited in scope, classical computers are still the preferred tools. But for very complex problems, quantum computers can save time by narrowing down the range of possible answers.

When will quantum computers be available?

Over the next few years, the major players in quantum computing, as well as a small cohort of start-ups, will steadily increase the number of qubits that their computers can handle and improve how the technology functions. Progress in quantum computing, however, is expected to remain slow. According to our conversations with tech executives, investors, and academics in quantum computing, 72 percent believe we’ll see a fully fault-tolerant quantum computer by 2035. The remaining 28 percent think this milestone won’t be reached until 2040 or later.

But some businesses will begin to derive value from quantum well before then. At first, businesses will receive quantum services via the cloud. Several major computing companies have already announced their quantum cloud offerings.

What are some obstacles that impede the development of quantum computing?

One major obstacle to the advancement of quantum computing is that qubits are volatile. Whereas a bit in today’s classical computers is in a state of either one or zero, a qubit can be any possible combination of the two. When a qubit changes its status, inputs can be lost or altered, throwing off the accuracy of the results. Another obstacle to development is that a quantum computer operating at the scale needed to deliver significant breakthroughs will require potentially millions of qubits to be connected. The few quantum computers that exist today are nowhere near that number.

Here are some other challenges facing the technologies that could support quantum computing at scale:

• High-fidelity two-qubit gates at scale. Maintaining high fidelity (meaning accuracy and reliability greater than 99.99 percent) is required for fault-tolerant quantum computers. Doing so at scale will be difficult.
• Speed. Qubits need to retain their quantum state to be able to interact with one another. Even in specific environmental conditions, they will eventually degrade. For quantum computers to operate at scale, gate operations will need to move very quickly to complete computations before qubits degrade.
• Multiqubit networking. Connecting, or networking, qubits to one another could theoretically make quantum computers much more powerful. The key challenge here is connecting qubits across chips, or from one physical quantum computer to anothe

• Individual qubit control at scale. The control of individual qubits becomes increasingly complex as the number of qubits increases.
• Cooling power and environmental control. As quantum computers become larger, the size and power requirements of the cooling equipment become more and more expensive, from both a cost and an environmental standpoint. Currently, powering a quantum computer large enough to connect millions of qubits is cost prohibitive.
• Manufacturability. Producing large numbers of quantum computers will require automating both the manufacturing and testing processes. The production of certain quantum computers may require developing entirely new manufacturing techniques.

How can classical computers and quantum computers work together?

Slowly, at first. Initially, quantum computing will be used alongside classical computing to solve multivariable problems. One example? Quantum computers can narrow the range of possible solutions to a finance or logistics problem, helping a company reach the best solution faster. This kind of slower progress will be the norm until quantum computing advances enough to deliver more significant breakthroughs

What are some potential business use cases for quantum computers?

Quantum computers have four fundamental capabilities that differentiate them from today’s classical computers:

1. Quantum simulation. Quantum computers can model complex molecules, which may eventually help reduce development time for chemical and pharmaceutical companies. Scientists looking to develop new drugs need to examine the structure of a molecule to understand how it will interact with other molecules. It’s almost impossible for today’s computers to provide accurate simulations, because each atom interacts with other atoms in complex ways. But experts believe that quantum computers are powerful enough to eventually be able to model even the most complex molecules in the human body. This opens up the possibility for faster development of new drugs and new, transformative cures.
2. Optimization and search. Every industry relies in one way or another on optimization. Where are robots best placed on a factory floor? What’s the shortest route for a company’s delivery trucks? There are almost infinite questions that need to be answered to optimize for efficiency and value creation. With classical computing, companies must make one complicated calculation after another, which can be a time-consuming and costly process given the many potential variables of a situation. Since a quantum computer is able to work with multiple variables simultaneously, it can be used to quickly narrow the range of possible answers. From there, classical computing can be used to zero in on one precise answer.

1. Quantum AI. Quantum computers have the potential to work with better algorithms that could transform machine learning across a diverse range of industries, from automotive to pharmaceuticals. In particular, quantum computers could accelerate the arrival of self-driving vehicles. Companies like Ford, GM, Volkswagen, and numerous mobility start-ups are running video and image data through complex neural networks. Their goal? To use AI to teach a car to make crucial driving decisions. Quantum computers’ ability to perform multiple complex calculations with many variables simultaneously allows for faster training of such AI systems.
2. Prime factorization. Businesses today use large, complex prime numbers as the basis for their encryption efforts, numbers too large for classical computers to process. Quantum computing will be able to use algorithms to solve these complex prime numbers easily, a process called prime factorization. (In fact, a quantum algorithm known as Shor’s algorithm theoretically already can; there’s just not a computer powerful enough to run it.) Once quantum computers have advanced enough, new quantum-encryption technologies will be needed to protect online services. Scientists are already at work on quantum cryptography to prepare for this eventuality. McKinsey estimates quantum computers will be powerful enough for prime factorization by the late 2020s at the very earliest.
3. As these capabilities develop at pace with quantum computing power, use cases will proliferate

What industries stand to benefit the most from quantum computing?

Research suggests that several industries in particular stand to reap the greatest short-term benefits from quantum computing based on the use cases discussed in the previous section. Collectively—and conservatively—the value at stake for these industries could be in the trillions of dollars.

• Pharmaceuticals. Quantum computing has the potential to revolutionize the research and development of molecular structures in the biopharmaceuticals industry. With quantum technologies, research and development for drugs could become less reliant on trial and error, and therefore more efficient. (Read more on how quantum computing stands to affect the pharmaceutical industry.)
• Chemicals. Quantum computing could be used to improve catalyst design, which could enable savings on existing production processes. Innovative catalysts could also enable the replacement of petrochemicals with more sustainable feedstock or the breakdown of carbon for CO2 usage. (Read more on how quantum computing might affect the chemicals industry.)
• Mobility. Quantum computing could result in a mobility ecosystem that is fully connected, intelligent, and environmentally friendly. Changes depend on the rapid and smooth exchange of vast amounts of data between in-vehicle computers and computers elsewhere. Quantum computers can process these large amounts of data in ways existing computers can’t, making this type of data exchange a realistic possibility. (Read more about how quantum technologies could affect the mobility industry.)
• Automotive. Within the mobility sector, the automotive industry could benefit from quantum computing in its R&D, product design, supply chain management, production, and mobility and traffic management. For example, quantum computing could be applied to decrease manufacturing costs by optimizing complex multirobot processes including welding, gluing, and painting. (Read more about how quantum technologies could affect the automotive industry.)

• Finance. Quantum computing use cases in finance are slightly further in the future. The long-term promise of quantum computing in finance lies in portfolio and risk management. One example could be quantum-optimized loan portfolios that focus on collateral to allow lenders to improve their offerings. By the time a fault-tolerant quantum computer is available, we estimate that the use cases in finance could create $622 billion in value. (Read more about how quantum computing could affect financial services.)

These five industries likely stand to gain the most from quantum computing, at least at first. But leaders in every sector can—and should—prepare for the inevitable quantum advancements of the coming years.

What is quantum computing? | McKinsey

Introduction (Python Code) Economic Networks Theory and Computation

 

Economic Networks Theory and Computation

Chapter 1 - Introduction (Python Code)

John Stachurski and Thomas J. Sargent

Chapter 1 - Introduction (Python Code)

! pip install --upgrade quantecon_book_networks kaleido

Show code cell output

We begin by importing the quantecon package as well as some functions and data that have been packaged for release with this text.

import quantecon as qe
import quantecon_book_networks
import quantecon_book_networks.input_output as qbn_io
import quantecon_book_networks.data as qbn_data
import quantecon_book_networks.plotting as qbn_plot
ch1_data = qbn_data.introduction()
default_figsize = (6, 4)
export_figures = False

Next we import some common python libraries.

import numpy as np
import pandas as pd
import networkx as nx
import statsmodels.api as sm
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import matplotlib.ticker as ticker
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import matplotlib.patches as mpatches
import plotly.graph_objects as go
quantecon_book_networks.config("matplotlib")

Motivation

International trade in crude oil 2021

We begin by loading a NetworkX directed graph object that represents international trade in crude oil.

DG = ch1_data["crude_oil"]

Next we transform the data to prepare it for display as a Sankey diagram.

nodeid = {}
for ix,nd in enumerate(DG.nodes()):
    nodeid[nd] = ix

# Links
source = []
target = []
value = []
for src,tgt in DG.edges():
    source.append(nodeid[src])
    target.append(nodeid[tgt])
    value.append(DG[src][tgt]['weight'])

Finally we produce our plot.

fig = go.Figure(data=[go.Sankey(
    node = dict(
      pad = 15,
      thickness = 20,
      line = dict(color = "black", width = 0.5),
      label = list(nodeid.keys()),
      color = "blue"
    ),
    link = dict(
      source = source,
      target = target,
      value = value
  ))])


fig.update_layout(title_text="Crude Oil", font_size=10, width=600, height=800)
if export_figures:
    fig.write_image("figures/crude_oil_2021.pdf")
fig.show(renderer='svg')

International trade in commercial aircraft during 2019

For this plot we will use a cleaned dataset from Harvard, CID Dataverse.

DG = ch1_data['aircraft_network']
pos = ch1_data['aircraft_network_pos']

We begin by calculating some features of our graph using the NetworkX and the quantecon_book_networks packages.

centrality = nx.eigenvector_centrality(DG)
node_total_exports = qbn_io.node_total_exports(DG)
edge_weights = qbn_io.edge_weights(DG)

Now we convert our graph features to plot features.

node_pos_dict = pos

node_sizes = qbn_io.normalise_weights(node_total_exports,10000)
edge_widths = qbn_io.normalise_weights(edge_weights,10)

node_colors = qbn_io.colorise_weights(list(centrality.values()),color_palette=cm.viridis)
node_to_color = dict(zip(DG.nodes,node_colors))
edge_colors = []
for src,_ in DG.edges:
    edge_colors.append(node_to_color[src])

Finally we produce the plot.

fig, ax = plt.subplots(figsize=(10, 10))
ax.axis('off')

nx.draw_networkx_nodes(DG, 
                        node_pos_dict, 
                        node_color=node_colors, 
                        node_size=node_sizes, 
                        linewidths=2, 
                        alpha=0.6, 
                        ax=ax)

nx.draw_networkx_labels(DG, 
                        node_pos_dict,  
                        ax=ax)

nx.draw_networkx_edges(DG, 
                        node_pos_dict, 
                        edge_color=edge_colors, 
                        width=edge_widths, 
                        arrows=True, 
                        arrowsize=20,  
                        ax=ax,
                        node_size=node_sizes, 
                        connectionstyle='arc3,rad=0.15')

if export_figures:
    plt.savefig("figures/commercial_aircraft_2019_1.pdf")
plt.show()

Spectral Theory

Spectral Radii

Here we provide code for computing the spectral radius of a matrix.

def spec_rad(M):
    """
    Compute the spectral radius of M.
    """
    return np.max(np.abs(np.linalg.eigvals(M)))

M = np.array([[1,2],[2,1]])
spec_rad(M)

3.0000000000000004

This function is available in the quantecon_book_networks package, along with several other functions for used repeatedly in the text. Source code for these functions can be seen here.

qbn_io.spec_rad(M)

3.0000000000000004

Probability

The unit simplex in

Here we define a function for plotting the unit simplex.

def unit_simplex(angle):
    
    fig = plt.figure(figsize=(10, 8))
    ax = fig.add_subplot(111, projection='3d')

    vtx = [[0, 0, 1],
           [0, 1, 0], 
           [1, 0, 0]]
    
    tri = Poly3DCollection([vtx], color='darkblue', alpha=0.3)
    tri.set_facecolor([0.5, 0.5, 1])
    ax.add_collection3d(tri)

    ax.set(xlim=(0, 1), ylim=(0, 1), zlim=(0, 1), 
           xticks=(1,), yticks=(1,), zticks=(1,))

    ax.set_xticklabels(['$(1, 0, 0)$'], fontsize=16)
    ax.set_yticklabels([f'$(0, 1, 0)$'], fontsize=16)
    ax.set_zticklabels([f'$(0, 0, 1)$'], fontsize=16)

    ax.xaxis.majorTicks[0].set_pad(15)
    ax.yaxis.majorTicks[0].set_pad(15)
    ax.zaxis.majorTicks[0].set_pad(35)

    ax.view_init(30, angle)

    # Move axis to origin
    ax.xaxis._axinfo['juggled'] = (0, 0, 0)
    ax.yaxis._axinfo['juggled'] = (1, 1, 1)
    ax.zaxis._axinfo['juggled'] = (2, 2, 0)
    
    ax.grid(False) 
    
    return ax

We can now produce the plot.

unit_simplex(50)
if export_figures:
    plt.savefig("figures/simplex_1.pdf")
plt.show()

Independent draws from Student’s t and Normal distributions

Here we illustrate the occurrence of “extreme” events in heavy tailed distributions. We start by generating 1,000 samples from a normal distribution and a Student’s t distribution.

from scipy.stats import t
n = 1000
np.random.seed(123)

s = 2
n_data = np.random.randn(n) * s

t_dist = t(df=1.5)
t_data = t_dist.rvs(n)

When we plot our samples, we see the Student’s t distribution frequently generates samples many standard deviations from the mean.

fig, axes = plt.subplots(1, 2, figsize=(8, 3.4))

for ax in axes:
    ax.set_ylim((-50, 50))
    ax.plot((0, n), (0, 0), 'k-', lw=0.3)

ax = axes[0]
ax.plot(list(range(n)), t_data, linestyle='', marker='o', alpha=0.5, ms=4)
ax.vlines(list(range(n)), 0, t_data, 'k', lw=0.2)
ax.get_xaxis().set_major_formatter(
    ticker.FuncFormatter(lambda x, p: format(int(x), ',')))
ax.set_title(f"Student t draws", fontsize=11)

ax = axes[1]
ax.plot(list(range(n)), n_data, linestyle='', marker='o', alpha=0.5, ms=4)
ax.vlines(list(range(n)), 0, n_data, lw=0.2)
ax.get_xaxis().set_major_formatter(
    ticker.FuncFormatter(lambda x, p: format(int(x), ',')))
ax.set_title(f"$N(0, \sigma^2)$ with $\sigma = {s}$", fontsize=11)

plt.tight_layout()
if export_figures:
    plt.savefig("figures/heavy_tailed_draws.pdf")
plt.show()

CCDF plots for the Pareto and Exponential distributions

When the Pareto tail property holds, the CCDF is eventually log linear. Here we illustrates this using a Pareto distribution. For comparison, an exponential distribution is also shown. First we define our domain and the Pareto and Exponential distributions.

x = np.linspace(1, 10, 500)

α = 1.5
def Gp(x):
    return x**(-α)

λ = 1.0
def Ge(x):
    return np.exp(-λ * x)

We then plot our distribution on a log-log scale.

fig, ax = plt.subplots(figsize=default_figsize)

ax.plot(np.log(x), np.log(Gp(x)), label="Pareto")
ax.plot(np.log(x), np.log(Ge(x)), label="Exponential")

ax.legend(fontsize=12, frameon=False, loc="lower left")
ax.set_xlabel("$\ln x$", fontsize=12)
ax.set_ylabel("$\ln G(x)$", fontsize=12)

if export_figures:
    plt.savefig("figures/ccdf_comparison_1.pdf")
plt.show()

Empirical CCDF plots for largest firms (Forbes)

Here we show that the distribution of firm sizes has a Pareto tail. We start by loading the forbes_global_2000 dataset.

dfff = ch1_data['forbes_global_2000']

We calculate values of the empirical CCDF.

data = np.asarray(dfff['Market Value'])[0:500]
y_vals = np.empty_like(data, dtype='float64')
n = len(data)
for i, d in enumerate(data):
    # record fraction of sample above d
    y_vals[i] = np.sum(data >= d) / n

Now we fit a linear trend line (on the log-log scale).

x, y = np.log(data), np.log(y_vals)
results = sm.OLS(y, sm.add_constant(x)).fit()
b, a = results.params

Finally we produce our plot.

fig, ax = plt.subplots(figsize=(7.3, 4))

ax.scatter(x, y, alpha=0.3, label="firm size (market value)")
ax.plot(x, x * a + b, 'k-', alpha=0.6, label=f"slope = ${a: 1.2f}$")

ax.set_xlabel('log value', fontsize=12)
ax.set_ylabel("log prob.", fontsize=12)
ax.legend(loc='lower left', fontsize=12)
    
if export_figures:
    plt.savefig("figures/empirical_powerlaw_plots_firms_forbes.pdf")
plt.show()

Graph Theory

Zeta and Pareto distributions

We begin by defining the Zeta and Pareto distributions.

γ = 2.0
α = γ - 1

def z(k, c=2.0):
    return c * k**(-γ)

k_grid = np.arange(1, 10+1)

def p(x, c=2.0):
    return c * x**(-γ)

x_grid = np.linspace(1, 10, 200)

Then we can produce our plot

fig, ax = plt.subplots(figsize=default_figsize)
ax.plot(k_grid, z(k_grid), '-o', label='zeta distribution with $\gamma=2$')
ax.plot(x_grid, p(x_grid), label='density of Pareto with tail index $\\alpha$')
ax.legend(fontsize=12)
ax.set_yticks((0, 1, 2))
if export_figures:
    plt.savefig("figures/zeta_1.pdf")
plt.show()

NetworkX digraph plot

We start by creating a graph object and populating it with edges.

G_p = nx.DiGraph()

edge_list = [
    ('p', 'p'),
    ('m', 'p'), ('m', 'm'), ('m', 'r'),
    ('r', 'p'), ('r', 'm'), ('r', 'r')
]

for e in edge_list:
    u, v = e
    G_p.add_edge(u, v)

Now we can plot our graph.

fig, ax = plt.subplots()
nx.spring_layout(G_p, seed=4)
nx.draw_spring(G_p, ax=ax, node_size=500, with_labels=True, 
                 font_weight='bold', arrows=True, alpha=0.8,
                 connectionstyle='arc3,rad=0.25', arrowsize=20)
if export_figures:
    plt.savefig("figures/networkx_basics_1.pdf")
plt.show()

The DiGraph object has methods that calculate in-degree and out-degree of vertices.

G_p.in_degree('p')

3

G_p.out_degree('p')

1

Additionally, the NetworkX package supplies functions for testing communication and strong connectedness, as well as to compute strongly connected components.

G = nx.DiGraph()
G.add_edge(1, 1)
G.add_edge(2, 1)
G.add_edge(2, 3)
G.add_edge(3, 2)
list(nx.strongly_connected_components(G))

[{1}, {2, 3}]

Like NetworkX, the Python library quantecon provides access to some graph-theoretic algorithms.

In the case of QuantEcon’s DiGraph object, an instance is created via the adjacency matrix.

A = ((1, 0, 0),
     (1, 1, 1),
     (1, 1, 1))
A = np.array(A) # Convert to NumPy array
G = qe.DiGraph(A)

G.strongly_connected_components

[array([0]), array([1, 2])]

International private credit flows by country

We begin by loading an adjacency matrix of international private credit flows (in the form of a NumPy array and a list of country labels).

Z = ch1_data["adjacency_matrix"]["Z"]
Z_visual= ch1_data["adjacency_matrix"]["Z_visual"]
countries = ch1_data["adjacency_matrix"]["countries"]

To calculate our graph’s properties, we use hub-based eigenvector centrality as our centrality measure for this plot.

centrality = qbn_io.eigenvector_centrality(Z_visual, authority=False)

Now we convert our graph features to plot features.

node_colors = cm.plasma(qbn_io.to_zero_one_beta(centrality))

Finally we produce the plot.

X = qbn_io.to_zero_one_beta(Z.sum(axis=1))

fig, ax = plt.subplots(figsize=(8, 10))
plt.axis("off")

qbn_plot.plot_graph(Z_visual, X, ax, countries,
           layout_type='spring',
           layout_seed=1234,
           node_size_multiple=3000,
           edge_size_multiple=0.000006,
           tol=0.0,
           node_color_list=node_colors) 

if export_figures:
    plt.savefig("figures/financial_network_analysis_visualization.pdf")
plt.show()

Centrality measures for the credit network

This figure looks at six different centrality measures.

We begin by defining a function for calculating eigenvector centrality.

Hub-based centrality is calculated by default, although authority-based centrality can be calculated by setting authority=True.

def eigenvector_centrality(A, k=40, authority=False):
    """
    Computes the dominant eigenvector of A. Assumes A is 
    primitive and uses the power method.  
    
    """
    A_temp = A.T if authority else A
    n = len(A_temp)
    r = spec_rad(A_temp)
    e = r**(-k) * (np.linalg.matrix_power(A_temp, k) @ np.ones(n))
    return e / np.sum(e)

Here a similar function is defined for calculating Katz centrality.

def katz_centrality(A, b=1, authority=False):
    """
    Computes the Katz centrality of A, defined as the x solving

    x = 1 + b A x    (1 = vector of ones)

    Assumes that A is square.

    If authority=True, then A is replaced by its transpose.
    """
    n = len(A)
    I = np.identity(n)
    C = I - b * A.T if authority else I - b * A
    return np.linalg.solve(C, np.ones(n))

Now we generate an unweighted version of our matrix to help calculate in-degree and out-degree.

D = qbn_io.build_unweighted_matrix(Z)

We now use the above to calculate the six centrality measures.

outdegree = D.sum(axis=1)
ecentral_hub = eigenvector_centrality(Z, authority=False)
kcentral_hub = katz_centrality(Z, b=1/1_700_000)

indegree = D.sum(axis=0)
ecentral_authority = eigenvector_centrality(Z, authority=True)
kcentral_authority = katz_centrality(Z, b=1/1_700_000, authority=True)

Here we provide a helper function that returns a DataFrame for each measure. The DataFrame is ordered by that measure and contains color information.

def centrality_plot_data(countries, centrality_measures):
    df = pd.DataFrame({'code': countries,
                       'centrality':centrality_measures, 
                       'color': qbn_io.colorise_weights(centrality_measures).tolist()
                       })
    return df.sort_values('centrality')

Finally, we plot the various centrality measures.

centrality_measures = [outdegree, indegree, 
                       ecentral_hub, ecentral_authority, 
                       kcentral_hub, kcentral_authority]

ylabels = ['out degree', 'in degree',
           'eigenvector hub','eigenvector authority', 
           'Katz hub', 'Katz authority']

ylims = [(0, 20), (0, 20), 
         None, None,   
         None, None]


fig, axes = plt.subplots(3, 2, figsize=(10, 12))

axes = axes.flatten()

for i, ax in enumerate(axes):
    df = centrality_plot_data(countries, centrality_measures[i])
      
    ax.bar('code', 'centrality', data=df, color=df["color"], alpha=0.6)
    
    patch = mpatches.Patch(color=None, label=ylabels[i], visible=False)
    ax.legend(handles=[patch], fontsize=12, loc="upper left", handlelength=0, frameon=False)
    
    if ylims[i] is not None:
        ax.set_ylim(ylims[i])

if export_figures:
    plt.savefig("figures/financial_network_analysis_centrality.pdf")
plt.show()

Computing in and out degree distributions

The in-degree distribution evaluated at is the fraction of nodes in a network that have in-degree

. The in-degree distribution of a NetworkX DiGraph can be calculated using the code below.

def in_degree_dist(G):
    n = G.number_of_nodes()
    iG = np.array([G.in_degree(v) for v in G.nodes()])
    d = [np.mean(iG == k) for k in range(n+1)]
    return d

The out-degree distribution is defined analogously.

def out_degree_dist(G):
    n = G.number_of_nodes()
    oG = np.array([G.out_degree(v) for v in G.nodes()])
    d = [np.mean(oG == k) for k in range(n+1)]
    return d

Degree distribution for international aircraft trade

Here we illustrate that the commercial aircraft international trade network is approximately scale-free by plotting the degree distribution alongside with and

.

In this calculation of the degree distribution, performed by the NetworkX function degree_histogram, directions are ignored and the network is treated as an undirected graph.

def plot_degree_dist(G, ax, loglog=True, label=None):
    "Plot the degree distribution of a graph G on axis ax."
    dd = [x for x in nx.degree_histogram(G) if x > 0]
    dd = np.array(dd) / np.sum(dd)  # normalize
    if loglog:
        ax.loglog(dd, '-o', lw=0.5, label=label)
    else:
        ax.plot(dd, '-o', lw=0.5, label=label)

fig, ax = plt.subplots(figsize=default_figsize)

plot_degree_dist(DG, ax, loglog=False, label='degree distribution')

xg = np.linspace(0.5, 25, 250)
ax.plot(xg, 0.2 * xg**(-1.1), label='power law')
ax.set_xlim(0.9, 22)
ax.set_ylim(0, 0.25)
ax.legend()
if export_figures:
    plt.savefig("figures/commercial_aircraft_2019_2.pdf")
plt.show()

Random graphs

The code to produce the Erdos-Renyi random graph, used below, applies the combinations function from the itertools library. The function combinations(A, k) returns a list of all subsets of of size

. For example:

import itertools
letters = 'a', 'b', 'c'
list(itertools.combinations(letters, 2))

[('a', 'b'), ('a', 'c'), ('b', 'c')]

Below we generate random graphs using the Erdos-Renyi and Barabasi-Albert algorithms. Here, for convenience, we will define a function to plot these graphs.

def plot_random_graph(RG,ax):
    node_pos_dict = nx.spring_layout(RG, k=1.1)

    centrality = nx.degree_centrality(RG)
    node_color_list = qbn_io.colorise_weights(list(centrality.values()))

    edge_color_list = []
    for i in range(n):
        for j in range(n):
            edge_color_list.append(node_color_list[i])

    nx.draw_networkx_nodes(RG, 
                           node_pos_dict, 
                           node_color=node_color_list, 
                           edgecolors='grey', 
                           node_size=100,
                           linewidths=2, 
                           alpha=0.8, 
                           ax=ax)

    nx.draw_networkx_edges(RG, 
                           node_pos_dict, 
                           edge_color=edge_colors, 
                           alpha=0.4,  
                           ax=ax)

An instance of an Erdos–Renyi random graph

n = 100
p = 0.05
G_er = qbn_io.erdos_renyi_graph(n, p, seed=1234)

fig, axes = plt.subplots(1, 2, figsize=(10, 3.2))

axes[0].set_title("Graph visualization")
plot_random_graph(G_er,axes[0])

axes[1].set_title("Degree distribution")
plot_degree_dist(G_er, axes[1], loglog=False)

if export_figures:
    plt.savefig("figures/rand_graph_experiments_1.pdf")
plt.show()

An instance of a preferential attachment random graph

n = 100
m = 5
G_ba = nx.generators.random_graphs.barabasi_albert_graph(n, m, seed=123)

fig, axes = plt.subplots(1, 2, figsize=(10, 3.2))

axes[0].set_title("Graph visualization")
plot_random_graph(G_ba, axes[0])

axes[1].set_title("Degree distribution")
plot_degree_dist(G_ba, axes[1], loglog=False)

if export_figures:
    plt.savefig("figures/rand_graph_experiments_2.pdf")
plt.show()

Creative Commons License – 

https://networks.quantecon.org/ch_intro.html