2026-05-11 · paper

A slow walk through Random Dot Product Graphs

Work in progress. I’ll keep adding to this as I go; for now it’s just a starting frame.

In this post, which may well grow into a small series, I want to walk slowly through the two papers I’ve recently put up on arXiv, Random Dot Product Graphs as Dynamical Systems and Intensity Dot Product Graphs, with a couple more on the way. Those papers are written for the working mathematician, the kind of reader who wants the proofs lined up before deciding whether the ideas are worth chewing on. They do that job, I hope. They also fall short of engaging anyone who isn’t a working mathematician, which has always bothered me a little. There are ideas in this corner of network science that I think any curious person could enjoy, if they’re laid out gently enough.

So that’s what I’ll try here. A long, slow explanation, of the kind I’d give to a curious friend who’s patient enough to listen :-) Drawings will come too; words alone aren’t going to do the story justice.

Let’s begin from the very beginning.

Two friends to keep us company through this post (and the others to come): Anubis and Bastet, older deities from the Egyptian pantheon. They’ll show up whenever we need a concrete pair to point at.

What we’ll model between them is attention, desire, the regard one being turns toward another.

A complex network is, in the simplest description we can give it, a collection of interactions. We have a bunch of things, anything we like, people, species, neurons, web pages, machines on the internet, and some pairs of those things are related to each other while others aren’t. Sometimes the relation has a direction. Anubis might burn for Bastet without Bastet returning the flame. Sometimes both directions are possible. The shape of the whole pattern of relations is what we’ll call the network.

When mathematicians sit down to draw a network, they usually do it like this. The things become dots (we call them nodes). The relations become arrows or lines between the dots (we call them edges). Already we have an object on the page to argue about.

Two kinds of question come up when you stare at a real network for a while. The first one is descriptive: what does it look like, are there clusters, hubs, surprises? The second is generative: if I had to invent a simple rule that could have produced something like this, what would the rule be?

The Random Dot Product Graph model, RDPG for short, is one answer to the second question. It’s a recipe.

The recipe

To every node we attach two arrows. Let’s colour one yellow and one blue. Each arrow has some direction and some length. The yellow arrow describes how that node gives relations to others. The blue arrow describes how that node receives them.

Now take two nodes, Anubis and Bastet, and ask whether there should be an edge going from Anubis to Bastet.

Here’s the rule. Look at Anubis’s yellow arrow (his “outgoing personality”) and at Bastet’s blue arrow (her “incoming personality”). If those two arrows are long and they’re pointing roughly in the same direction, that’s a strong sign of compatibility: Anubis has a lot to give, Bastet has a lot of capacity to receive, and they agree about what kind of interaction this is. In that case, we say the probability for an edge to form from Anubis to Bastet is high. If either arrow is short, or if the two arrows point in noticeably different directions, the probability is low.

Anubis (A) and Bastet (B), each with a yellow (outgoing) and a blue (incoming) arrow. A’s yellow and B’s blue are parallel and roughly the same length, so their dot product is large: the edge from A to B is likely. The other two arrows go off in their own directions, contributing to other potential edges.

There’s a precise way to turn “long arrows pointing in the same direction” into a single number. Mathematicians have a name for it: the dot product of the two arrows. The dot product is large when the arrows are long and aligned, smaller when they’re shorter or pointing slightly off, and zero when they’re at right angles. The RDPG model is the sentence “the probability of an edge is the dot product of the right two arrows”, with a tiny bit of housekeeping to keep that probability between zero and one.

It’s worth slowing down on what the dot product is, geometrically. Take arrow $a$ and arrow $b$, and drop a perpendicular from $b$‘s tip down to $a$‘s line. The length of that perpendicular shadow is $|b| \cos \theta$. Multiply by the full length of $a$ and you’ve drawn a rectangle. That rectangle’s area is the dot product. You could equally well have done it the other way around (drop a shadow from $a$ onto $b$‘s line, then multiply by $|b|$); you’d get a rectangle of a different shape, with the same area.

The dot product as an area. Both rectangles have three things in common: the length of $a$, the length of $b$, and the cosine of the angle between them, just relabelled as which side is the base and which the height. Different shape, same area, the way a $2 \times 6$ strip and a $3 \times 4$ block both cover twelve unit squares. The arrows are still pointing somewhere; the area is no longer pointing anywhere. That switch from a directional thing to a single non-directional number is what the dot product does.

What about higher dimensions? The arrows in an RDPG often have more than two coordinates; does the area picture still hold? Yes, exactly as we drew it. Any two arrows, however many coordinates they each carry, together span a two-dimensional plane through the origin, and the whole story (the lengths, the angle, the two equal-area rectangles) plays out inside that plane. The ambient space can have ten thousand dimensions; the dot product of a single pair still draws itself on a flat patch of paper. Hypervolumes do show up in this corner of mathematics, and they have their own beauty, but they belong to operations that take three or more arrows at once.

A small constraint, before we go further

You might already be objecting. Arrows can point in any direction, surely, and the dot product of two arrows that point in genuinely opposite directions is a negative number. A negative number is not a probability. What’s going on?

The honest answer is that we restrict where the arrows are allowed to point. Pick any two arrows in the network: the angle between them is at most a right angle. They can be parallel, they can fan out a bit, they can be perpendicular. They cannot point in opposite directions.

This is the same as asking every arrow to live in the positive orthant of its space: the corner where every coordinate is non-negative. (Quick sanity check. The dot product is computed by multiplying the two arrows coordinate by coordinate and summing the results. If every coordinate of every arrow is non-negative, every product is non-negative, and the sum is non-negative too. The two are at most perpendicular by construction.) That’s the standard, classical RDPG.

There is a more recent extension that lets the arrows point anywhere they like. The dot product then ranges in $[-1, 1]$; the negative end of that range earns its own meaning, the active opposite of an interaction (think of Anubis and Bastet on a bad day, when the arrows go opposite ways, all carnage and destruction). You have to do extra work to keep that range meaningful as edge probabilities, the math is harder, and we’ll come back to it later. For the rest of this post, take “arrows” to mean “arrows in the positive orthant”.

Geometry from interactions

Up to here we haven’t said anything about the space the arrows live in. We didn’t have to. The story so far is entirely about arrows attached to nodes and the dot products between them.

Once you have the arrows, though, two spaces come along for free. Pick a common origin somewhere (the natural choice is the point where every coordinate is zero) and place each yellow arrow as a vector from that origin. The tip of Anubis’s yellow arrow gives his position in yellow space. The tip of Bastet’s yellow arrow gives hers. The same trick gives every node a position in blue space, the receiver’s view of the network.

A network in the RDPG world has two clouds of points, then: one in yellow space, one in blue space, locked together because every node contributes a point to each cloud (a node that gives nothing has its yellow tip parked at the origin; a node that receives nothing has its blue tip there, but it is still present in both spaces). The edges arise from how those two clouds line up under the dot-product rule. The interactions come first; the geometry emerges from them.

The four arrows, two readings of the same data. Attached to A and B, they describe how each node gives and receives. Slid back to a common origin per colour, their tips are A and B as points in yellow space (left) and in blue space (right).

Putting it together

The full recipe is: give every node a yellow arrow and a blue arrow, all in the positive orthant; for every ordered pair of nodes, flip a coin whose bias is the dot product of the giver’s yellow and the receiver’s blue; if it comes up heads, the edge appears in that direction, if tails, it doesn’t. Collect all the coin flips. The result is a random network.

That’s RDPG. The recipe looks short, but the mathematical work to build it was substantial. We’ve taken a vague intuition (‘two things compatible’) and turned it into a precise object made of arrows, dot products, and a coin flip. That move, from a fuzzy human concept to a clean mathematical object, is what mathematicians do for a living, and it’s the part of the work hardest to teach. We’ve already done it. The arithmetic and the proofs come later. What’s lovely is how far this little recipe carries us.

I’ll pick up the story from there next time.

Play with it

A small interactive widget. Drag either tip to move a vector; the two shadow rectangles redraw as you go. Watch the shapes; watch the areas.

There’s a toggle at the bottom right marked rotate together. Try switching it on and dragging a tip. What changes? What doesn’t? Hold onto whatever you notice; we’ll pick that thread up next time.