Ok, so the black hole glitch, as you may or may not know, is triggered by a high number of overlapping rods, so before we can do any math, lets define what we mean by an overlap:

An overlap, o, is an intersection of two different rods, or two different rods connected at a joint

Another important thing to note is that any two given rods can define at most one o.

Now we can solve some problems.

Problem

Given a stack of n rods connected at a single joint (commonly known as a weight, or a neutrino rod), what is o?

To solve this problem, let's start from the bottom, and work our way up.

When we have only one rod (n=1), we know that o=0.

With two rods, o=1.

With three rods, we gotta remember that each rod "handshakes" each other rod, so o=3.

With four rods it gets interesting, and n=6.

If we made a chart, it would look like this:

n | o

1 | 0

2 | 1

3 | 3

4 | 6

5 | 10

6 | 15

...

I'm not gonna offer a proof, but we can see from the table (and if we keep going on, the pattern continues), is that each value of o goes up by n-1 each time.

So, the recursive definition of o as a function of n is as follows:

f(n) = (n-1) + f(n-1)

where f(1) = 0

But wait, we still haven't answered the problem, and we're already getting bored, so let's go back to what we're trying to accomplish.

Take any value of n, such as 50... what is o?

Look, we obviously have a problem, as our recursive definition is as good as a potato for figuring out the answer (potatoes taste good, but can't do math), because starting at 50 and going back and back until 1 takes a long time. Sure, it's fun and easy to get a computer to do, and a quick run of the program

- Code: Select all
`print (overlaps(50));`

function overlaps(x) {

if (x == 1) {

return 0;

}

else {

return x - 1 + overlaps(x - 1);

}

}

gives us 1225 as an answer, but if we want to do this by hand, we need an iterative way of dealing with the problem.

Ok, again, I'm not going into exactly how we derive this, but n choose 2 gives us the equation:

n * (n-1)

2!

or simply:

n * (n-1)

2

(* is the multiplying operator)

This makes sense, because 50 times 49 divided by 2 is... 1225 .

The final function is:

f(n) = n * (n-1) / 2

So, now that we've got this equation, we have solved the first problem.

Problem

What is the minimum o required for the Black Hole Glitch to trigger? (This problem is assuming that this value is constant throughout every design/situation. We'll test this later.)

The first thing to do is find out how many rods are required to trigger the glitch in the simplest case, where there is one weight of sticks connected at a single joint. The lowest amount of rods happens to be 65 (no matter which kind of rod is used), so now it is quite trivial to find out o.

Either one of our algorithms will give us the answer of 2080.

The Road Ahead

Now that we know what o is required to trigger a black hole for a single weight, we can do some tests to see if this is consistent throughout any design.

A weight of 32 and a weight of 33 which overlap trigger the glitch. Deleting one rod stops it from triggering.

Two weights of 45 rods, one of 10, one of 4, and one of 3 (the total o of these weights is 2080) also triggers the glitch, but does not appear to be the least amount of rods that does in that configuration... anyone knows why? Perhaps it's something from the Note section at the bottom of the page.

Applications

Ah, so what can we do with this information? Perhaps someone with the API could find the average o of designs on levels with given difficulty and workshop size, so that we could make Black Hole resistant levels? I don't know, but I'm sure something useful can come out of this.

Note

Static and dynamic objects and goal pieces also effect Black Holes... I was testing on a blank level without any objects except the workshop and goal area.

It seems that rods which are near each other but don't overlap also count as they overlap....

If anybody has any comments, or something that I made a mistake in, use that comment section down there.... Thanks!