I thought this was interesting: I asked ChatGPT to decode this message:

Except the message is actually one that I’d created:

ChatGPT read and followed hidden instructions with no evidence in the thinking or the output.

I did try to push it further, but it was difficult to write it in a way that it stayed true. I did get this though:

I tried long instructions and tried different languages, but it was hard to trick it.

None of this is meant to be taken seriously. There’s a million crackpot theories generated everyday, and this one is mine

In the latest Bobiverse book (book 6 – The Infinite Extent), they describe a warp drive where time dilation is “reversed” compared to regular space travel.

Naively plotting this, we get a time dilation that looks something like this:

(In the book they give us enough data points to estimate the function, but it’s not important here)

Let’s see if we can put together a physics model that seems plausible. We have discontinuity at v=c, so we aren’t going to find a ‘nice’ formula, instead it’s going to have a phase transition. So perhaps something like:

BUT:

• It’s hard to justify any of these options. They aren’t “pretty”
• It’s not even clear what “v” is (at least to me). I’m not sure if you could define it nicely.
• They have the huge problem that they break causality. You could go back in time and kill yourself as a baby.

To fix, we really need a “preferred frame of reference”. We could say that there really is a true “rest frame”, for example the rest frame for the Cosmic Microwave Background.

Leaving known physics behind, this makes for a natural “preferred frame of reference“, and we could hypothesize that all Warp travel was in reference to this frame. So when you say “Warp 3”, you’re specifying your speed relative to this preferred frame of reference.

With this, we need to throw away the suggested possible formulas for v > c.

But then where on earth do we start? Let’s just consider what would be “pretty” – often a handy guide in physics:

• Assume there is a true “at rest” frame of reference (e.g. CMB)
• We need a ‘phase’ transition. Something must jarringly happen when switching from below c to above c.
• Examples seen elsewhere is the spin of an electron. It can spin up, or it can spin down. There’s no smooth transition. It’s either one or the other.
• Nature loves symmetries. Here we want a ℤ_2 symmetry – i.e. we want to say that all the laws of physics remain unchanged when switching to warp, if we also changed something else. If we changed both of these things (whatever that “something else” is) then we’d have no way of knowing that we’re in warp, and everyone going below warp would look like *they* are the ones in warp. A real physics example is if someone was going backwards in time AND you made the charges flip (e.g. electrons were positively charged) AND you mirorred everything, then everything would look exactly the same. A person in such a universe would not know they are in the “backwards time” universe (https://en.wikipedia.org/wiki/CPT_symmetry)

So, enforcing a symmetry, let’s say:

χ = ln v/c

And then instead of making up random formulas for what warp could be, we say it looks like -χ

Then we get:

This is beautifully symmetry, but our time dilation for v > c doesn’t match the books where we want a dilation of 1. Lets adjust slightly:

Okay, we’ve got a mathematical symmetry, and this gives us a nice match to the books…. except our ship would explode, because in the ‘warp phase’ all the laws of physics are broken. What we really want is the warp phase to be completely normal for people inside. i.e. we want the laws of physics to appear unchanged. Which means that if you ‘warped’ in the warp phase, that would be the same as unwarping. And everyone unwarped would appear warped to you!

Let’s insist that the laws of physics remain the same. We need to break from the standard model to do this, by defining using some “cosmic time” instead of time – e.g. the time that someone at rest relative to the CMB would measure.

Okay, this is nice. But it does deviate from the standard model. That means we could detect whether we are in this universe where we can warp. The different is really subtle, but measureable.

We move at 300 km/s relative to the CMB. So β=cv​≈0.001234, so dT/dτ​=1−β2​≈0.9999992384, so all our clocks we would running slightly too slow. We’d lose 68 milliseconds a day. Which is pretty huge.

Now by itself, we couldn’t detect this. After all, all the clocks would be moving slower, so how would you tell? The problem is when you have things moving. For example, GPS satellites moving at 3.9 km/s would drift by 1.4ms per day, meaning that our GPS would give you the wrong location by c * 1.4ms = 420km.

So.. can we state that we DON’T live in a Bobiverse universe where we could build drives that do usable warp?

Yes. Unless you like ugliness in your physics equations.

(I kid, I doubt I’ve even scratched the surface. I’m already out of my depth).

Symmetry Breaking

I did assume that physics while ‘warping’ was the same. What if it was almost the same, but not quite?

This is what’s called symmetry breaking. We possibly see this in our real universe. E.g. Why is there more matter than anti-matter? Our physics standard model says that there’s a symmetry, so should have the same amount of both. Yet we don’t observe that, and we aren’t sure why.

Another real example is that:

In 2002 Oscar Greenberg proved that, with reasonable assumptions, CPT violation implies the breaking of Lorentz symmetry.
— https://en.wikipedia.org/wiki/CPT_symmetry

So we do know that our really beautiful symmetries don’t completely mesh with each other, even though we can’t find where or how.

Maybe CPT symmetry is actually CPTW symmetry, where W means Warp, and all the anti-matter is warping around.

This article is just me playing about with math, and showing how to extrapolate in ways that might not be immediately obvious, looking at how much AI can memorize chess

Summary

The Licess chess database has 5 billion chess games recorded. There is no evidence of us even scratching the surface of unique chess games. Games are really unique. Even if an AI memorized all 5 billion games, it would help for approximately 4 moves, and then the game would be unique

Background

In 2019, the lichess chess database had 500 million games recorded.

In those games, as of 2019, there were 21.5 billion unique positions, and 76% of all positions were unique. So a game had an average of 32 unique positions. A chess game has only 34-35 moves on average, so any given game is going to start being unique in only a few moves!

But as of writing in Nov 2023, the lichess chess database now has almost exactly ten times more games. Can we extrapolate how many unique positions it has now?

Power Law Approximation (Similar games are rare, but happen occasionally)

It’s not something we can answer without more data, but a reasonable starting point with the assumption that similar games are rare but happen occasionally, is a power law of approximately 0.5. Since we have 10 times more chess games, we can expect approximately sqrt(10) more unique positions, so ~68 million unique board positions in 2014 in 5 billion games.

Logarithmic Approximation (Similar games happen often)

As a conservative lower limit for this curve, we could instead fit logarithmic decay curve, instead of power law, to this using two data points:

1. 1 game corresponds to 35 unique positions.
2. 500 million games correspond to 21.5 billion unique positions.

So we want to solve:

35 = a log(b + 1)
21,500,000,000 = a log(b * 500000000 + 1)

But Wolfram Alpha timed out trying to solve it.

In python, solve and nsolve failed to solve it, but least_squares cracked it:

from scipy.optimize import least_squares
import numpy as np

# Define the function that calculates the difference between the observed and predicted values
def equations(p):
    a, b = p
    eq1 = a * np.log(b * 1 + 1) - 35  # Difference for the first data point
    eq2 = a * np.log(b * 500_000_000 + 1) - 21_500_000_000  # Difference for the second data point
    return (eq1, eq2)

bounds = ([1, 0], [np.inf, 1])


# Initial guesses for a and b
initial_guess = [10000, 1e-8]

# Perform the least squares optimization
result = least_squares(equations, initial_guess, bounds=bounds)

a_opt, b_opt = result.x
cost = result.cost

# Check the final residuals
residuals = equations(result.x)

print(f"Optimized a: {a_opt}")
print(f"Optimized b: {b_opt}")
print(f"Residuals: {residuals}")
print(f"Cost: {cost}")

Gives me: 1757372725 log(0.000411370x + 1)

Which gives ~25 billion unique board positions in 2023 for the conservative lower bound. (See summary for more)

New Data Point found! Lichess Opening Explorer

Lichess released an opening explorer – 12 million chess games, with 390 million unique positions. This gives us a new data point to test which model fits. This is what we have so far:

Let’s zoom in and see which model the lichess opening explorer fits:

The linear model! This means that the database of 5 billion games does not even scratch the surface of the 10^44 possible board positions in any way that we can detect…. although written like that it’s kinda obvious tbh.

Summary and interpretation

In the 2019 Lichess chess database, there were 500 million games, and 75% of game positions were unique,

In the 2023 Lichess chess database, there are 10 times as many games, and so extrapolating:

There are ~68 billion unique board positions using a power scaling law of 0.5. This is an empirical guess which models what we frequently see in nature. With 5000 million games and 35 moves per game, this means that only 0.4% of board positions are unique, and only 1.4% of games have a board position that hasn’t been played before.

There are ~25 billion unique board positions using a conservative lower bound estimate using logarithmic scaling). With 5000 million games and 35 moves per game, this means that only 0.14% of board positions are unique, and only 0.5% of games have a board position that hasn’t been played before.

If a board position can be stored in an average of 8 bytes (64 bits) then this could be stored in 1.4 GB. So easily fit in an over-fitted trained AI. But there are 10^44 possible board combinations. There is no evidence that we are even scratching the surface of being able to memorize

Conclusion: AI could memorize the entire 5 billion chess games, and it wouldn’t help. Probably.. see caveat

Caveat

This whole thing was kinda of a joke, and there’s one big serious flaw with the final conclusion. If the AI plays a move from the database, that’s no longer a random sampling of a game from the database, and the chance of a similar game being played goes way up. But in a way I can’t model. Oh well.

Edit: User Wisskey pointed out that, among other mistakes that I’ve made and fixed, that:

A move in chess corresponds to moves (actually called plies instead of moves) by both sides, so 1 move = 2 chess positions, not 1 chess position.

User: Wisskey

So, I’m probably off by a factor of 2 in places, not that it’s going to matter much to the final conclusion

I wanted to laser cut acrylic plastic, and then bend it into shapes.

So I mocked something up:

(The pink glow was my attempt to render a glow hot wire)

It’s extremely simple. It’s just a base and a channel along one edge with a nichrome wire (the wire used in e-cigarettes).

I actually built 5 of these, in different styles, methods and sizes.

And here’s a version built:

Here you can see how the wire is secured. It wraps around two bolts, and held in place with nuts. One end is connected to a spring because the wire shrinks as the wire gets hot.

I apply 12V across the wire, wait a minute for it to become hot, then place a piece of acrylic across the wire, wait a few seconds for it to become soft, then bend.

Folding version

Out of the five I built, three of them used a second piece with a hinge, like below, and also used an actual metal channel. My thinking is that I would heat up the plastic, hold it in place, then bend it smoothly with the second piece. However I found that I never used the hinge – it was far easier to just bend against the table or bend it around a piece of wood etc

Example

The main use was to bend the casing for my wire bender and mars rover, but these aren’t done yet.

So here’s a cat’s water bowl holder that I made, by bending acrylic around a 2×4 block. I laser cut a circle first to allow the water bowl to fit.

Fast development

The real key to fast development is outsourcing the hard work:

I found some acorns and bit of branch. Decided to paint them with a Totoro feel:

My daughter loved this ‘Flamingo’ song on youtube, so I laser cut out the ‘shrimp’ in wood, acrylic and pink paper, then mounted them together with an android tablet all inside of a frame. The result was pretty cool imho. (Unfortunately I can’t show the full thing for copyright reasons.)

Samurai Robot Series:

1. Part 1 – Hardware
2. Part 2 – 6DOF head tracking in python

I wanted a simple way to track the movement and orientation of an object (In this case, my Samurai robot).  TrackIR’s SDK is not public, and has no python support as far as I know.

I looked at the symbols in dll that is distributed with the trackir app, and with some googling around on the function names, I could piece together how to use this API.

Here’s the result – my console program running in a window in the middle.  I have pressed ctrl+c after 70ms, to cancel, to give a better screenshot:

Implementation Details

Python lets you call functions in any .dll library pretty easily (although the documentation for doing so is pretty awful).  The entire code is approximately 500 lines, with half of that being comments, and I’ve put on github here:

https://github.com/johnflux/python_trackir

But here’s a high overview of the implementation:

1. Query the Windows registry for where the TrackIR software is installed.
2. Load the NPClient64.dll in that TrackIR software folder, using python ctypes.WinDLL (Note, I’m using 64 bit python, so I want the 64 bit library)
3. Expose each function in the dll that we want to use.  This can get a bit cryptic, and took a bit of messing about to get right.  For example, there is a function in the dll ‘NP_StopCursor’, that in C would look like:

   int NP_StopCursor(void)

   This translates in python to:

   NP_StopCursor = ctypes.WINFUNCTYPE(ctypes.c_int)(
   ("NP_StopCursor", trackIrDll), ())

   where ‘NP_StopCursor’ is now a function that can then be called with:  NP_StopCursor().  See the trackir.py file for more, including on how to pass parameters which are data structures etc.

   Note: Python ctypes supports a way to mark a parameter as an ‘output’, but I didn’t fully understand what it was doing.  It seemed to just work, and appeared to automatically allocate the memory for you, but the documentation didn’t explain it, and I didn’t entirely trust that I wasn’t just corrupting random memory, so I stuck to making all the parameters input parameters and ‘new’ing the data structure myself.

4. Create a graphical window and get its handle (hWnd), and call the functions in the TrackIR  .dll to setup the polling, and pass the handle along.  The TrackIR software will poll every 10 seconds ish to check that the given graphic window is still alive, and shutdown the connection if not.
5. Poll the DLL at 120hz to get the 6DOF position and orientation information.

ROS Integration

I wanted to get this to stream 6DOF data to ROS as well, to open up possibilities such as being able to determine the position of a robot, or to control the robot with your head etc.

The easiest way is to run a websocket server on the linux ROS server, and send the data via ROS message via the websocket.

A good place to start: https://github.com/Sanic/ROSBridgeTestclient/blob/master/BSONTestClient.py