I’ve introduced you to *edges* between *two* nodes:

and I’ve shown you *graphs* made up of these *binary* edges:

I’ve also introduced you to *hyperedges* between *three* nodes:

and I’ve shown you *hypergraphs* made up of these *ternary* edges:

I’ve drawn all these edges and hyperedges as straight lines.

Some edges and hyperedges, however, *can’t* be drawn as straight lines, because they loop back on themselves.

These loops and self-loops might seem unassuming additions to our repertoire of edges and hyperedges.

But don’t let their curvy humility fool you.

They can play a crucial role in the evolution of graphs and hypergraphs... which means that they might play a crucial role in the evolution of the universe itself.

## Drawn out

Let’s start with a binary edge from node 1 to node 2.

We can represent it visually as an arrow from a dot with the number 1 on it, representing node 1, to a dot with the number 2 on it, representing node 2:

*Or* we can represent it *numerically* as the number 1 followed by a comma followed by the number 2, enclosed in curly brackets:

OK, let’s add another binary edge, from node 2 to node 3.

Here’s the visual representation, an arrow from a dot with the number 2 on it to a dot with the number 3 on it:

And here’s the numerical representation, the number 2 followed by a comma followed by the number 3 in curly brackets:

Now let’s show both edges.

Here they are represented visually, as an arrow from node 1 to node 2 and another arrow from node 2 to node 3:

And here they are represented numerically, as {1, 2}, {2, 3}:

## Double edged

You may think I’m drawing this out, in more ways than one, but here’s the point.

I’ve just shown you that {1, 2}, {2, 3} is a perfectly valid numerical representation of a graph with two edges: a binary edge from node 1 to node 2 and a binary edge from node 2 to node 3.

So why not {1, 2}, {1, 2}?

Isn’t that, too, a perfectly valid numerical representation of a graph with two edges: a binary edge from node 1 to node 2 and *another* binary edge *also* from node 1 to node 2?

It’s not hard to imagine how we might represent these edges *visually*.

That binary edge from node 1 to node 2? Well, obviously, we’re going to represent it as an arrow from a dot with the number 1 on it, representing node 1, to a dot with the number 2 on it, representing node 2.

And that *other* binary edge *also* from node 1 to node 2? Well, obviously, we’re going to represent it as *another* arrow from the dot with the number 1 on it, representing node 1, to the dot with the number 2 on it, representing node 2.

Of course, if we drew both edges as straight lines, they’d be on top of each other, and we wouldn’t be able to see that there are *two* edges between node 1 and node 2.

So instead, we’re going to draw both edges as *curved* lines:

We’ve never seen two edges between the same two nodes before, but when you represent it numerically as {1, 2}, {1, 2}, it doesn’t seem so strange, and when you represent it visually as two curved arrows between two nodes, well, that doesn’t seem so strange either, does it?

And we needn’t stop at *two* edges between the same nodes.

How about *three*?

Or *four*?

Or *five*?

## Double back

Let’s go one step further.

If we’re going to allow {1, 2}, {1, 2}, why not {1, 2}, {2, 1}?

This, too, seems a perfectly valid numerical representation of a graph with two edges: a binary edge from node 1 to node 2 and *another* binary edge from node 2 to node 1:

So now we have our first loop: two binary edges looping from one node to another and back again.

## Self seeking

But there’s actually a simpler loop we can construct.

Let’s go back to the first binary edges I mentioned.

If we can have a binary edge {1, 2} from node 1 to node 2:

and a binary edge {2, 3} from node 2 to node 3:

then it doesn’t seem unreasonable to imagine that we can have *any* two numbers in the curly brackets, representing a binary edge between *any* nodes.

So how about a binary edge {1, 1}?

There’s nothing in our numerical representation to *prevent* such a binary edge from node 1 to node 1.

Again, it’s not hard to imagine how we might represent this edge *visually*.

We’ll just need to bend an arrow back on itself, so that it loops from the dot with the number 1 on it, representing node 1, back to the *same* dot with the number 1 on it, representing the *same* node 1:

A binary edge that loops from a node back to the *same* node is called a *self-loop*.

## Hyperloops

So now I’ve shown you loops and self-loops in *graphs* of *binary* edges.

It won’t surprise you that we can also have loops and self-loops in *hypergraphs* of *ternary* edges.

Here’s a ternary edge between three nodes:

Remember that for ternary edges, we draw a web between the two arrows to show that this is *not* a *pair* of *binary* edges, one from node 1 to node 2 and another from node 2 to node 3, but a *single* *ternary* edge, from node 1 to node 2 to node 3.

You can probably guess where I’m going next.

If we can have a ternary edge {1, 2, 3}, then why not a ternary edge {1, 2, 1}?

Again, we draw a web between the two arrows to show that this is a *single* *ternary* edge, from node 1 to node 2 and back to node 1.

And, while we’re at it, why not a ternary edge {1, 1, 2}?

This edge goes from node 1, loops *back* to node 1, then goes to node 2.

And why not a ternary edge {1, 2, 2}?

*This* edge goes from node 1 to node 2, then loops *back* to node 2.

How about a ternary edge {1, 1, 1}?

This one goes from node 1, loops back to node 1, then loops back to node 1 *again*.

In each case, we draw a web between the two arrows, whether they’re straight or curved into a loop or a self-loop, to show that this is a *single* *ternary* edge, not a *pair* of *binary* edges.

You can see how this works: *any* sequence of numbers representing nodes represents a valid hyperedge between those nodes, whether it’s {1}, {1, 2}, {1, 2, 3}, {17, 98, 59, 22} or the double self-loop {1, 1, 1}.

## Loops rule

We can apply rules to loops and self-loops in the same way as to any other edges.

Take this simple rule:

To apply the rule, we find a self-loop on one node, delete that self-loop, and create a new edge from that node to a new node, as well as two new self-loops on that new node.

Here’s how it plays out:

Since any self-loop can generate a new edge to a new node with two new self-loops, the rule gives a branching, tree-like universe.

## Why loops matter

I’ve been wanting to introduce you to loops and self-loops for a long time now.

So many of the most complex and most promising graphs and hypergraphs of Wolfram Physics involve loops and self-loops.

I’m looking forward to showing you some of these beautiful universes in future articles.

But *that’s* not why loops matter.

The reason loops matter is that they *exist*, so if we exclude them from our models, then our models will be incomplete.

One of the most compelling aspects of Wolfram Physics is that it doesn’t make too many assumptions about our universe.

The Wolfram model doesn’t *assume* that only *binary* edges exist in our universe; it encompasses *all* edges, including unary, binary, ternary and so on up.

The Wolfram model doesn’t *assume* that only edges between *different* nodes exist in our universe; it encompasses *all* edges, including loops and self-loops between the *same* nodes.

The Wolfram model doesn’t *even* assume that there’s *one* rule that applies to our universe; it encompasses *all* rules in the ruliad.

If edges can be represented as sequences of numbers representing nodes, then the most *complete* model of the universe as a hypergraph must allow *any* sequence of numbers representing nodes, even if one or more of those numbers is repeated.

Including loops and self-loops in the hypergraph reduces the number of arbitrary assumptions we need to make in Wolfram Physics, making it more *complete*.