Time Travel KOTH

PhiNotPi

00:16

Hello everybody.

I decided to make this a separate room so that I didn't spam the nineteenth byte with stuff (including spoilers).

ASCII-only

Hello @Φ~π

PhiNotPi

I think a Primer-based KOTH would be pretty cool. By "Primer-based" I mean one that uses a very rigorous model of time travel, in which the restrictions are realistic (the only way to travel back to a particular time is to have a machine that was already activated at that time).

The main issue being that... there has to be some mechanism in place to limit the complexity... so that number of timelines isn't exponential, and that there's still some way to determine a "winner" when the outcomes vary across timelines.

@ASCII-only Hello

ASCII-only

hmm

hust assume the newest timeline is the only timeline?

PhiNotPi

I don't know if it's as simple as that (if I want to go off what the movie has).

ΛεγίωνΜάμμαλϠΨΠʹ

You know, I was thinking of something following the Novikov self-consistency principle

Novikov self-consistency principle

The Novikov self-consistency principle, also known as the Novikov self-consistency conjecture, is a principle developed by Russian physicist Igor Dmitriyevich Novikov in the mid-1980s to solve the problem of paradoxes in time travel, which is theoretically permitted in certain solutions of general relativity that contain what are known as closed timelike curves. The principle asserts that if an event exists that would give rise to a paradox, or to any "change" to the past whatsoever, then the probability of that event is zero. It would thus be impossible to create time paradoxes. == History... ==

ASCII-only

00:27

maybe just have a time limit? e.g. a certain number of days forward only

PhiNotPi

In the movie, sometimes different copies of the same character interact. In that case, I would have to have multiple "copies" of the same program running. I could probably do this by forcing programs to be "memoryless" (they can't store any information, and I pass them their complete subjective history every turn).

The self-consistency principle is another cool basis. It might be hard to "enforce" it though. For example, a "time portal" could open up and something comes from the future. There's no way to figure out what comes from the future until the future actually happens.

The Primer model would probably work a lot better in practice, since each instance of time travel creates a new timeline. I'll refer to the two portals/ends as the "X end" (portal in the past from the future) and the "Y end" (portal in the future to the past).

ASCII-only

also no ipc

PhiNotPi

@ASCII-only what?

ASCII-only

it's not gonna be easy to prevent two instances of the program from sharing memory

plus, in primer aaron did that

PhiNotPi

I might have a way to share information but it has to happen "in game."

ASCII-only

00:39

also how can you tell which is the final timeline

PhiNotPi

With the primer format, the player would first create the X end, and nothing would exit, then when they enter the Y end they arrive at the X end in a separate timeline.

@ASCII-only I'm not sure... I think the best solution would involve some method to determine/choose which copy of the program is "the one to follow."

I wonder... is it actually possible to model Primer as a single timeline that is being re-written, or do we actually need multiple timelines?

The first situation would give us a clear way of determining the "winner."

ASCII-only

i think single timeline would be just use the first time travel and start from there, idk whether to roll back the bots' memories

PhiNotPi

There'd be two copies of the program: one with rolled-back memories and one without.

ASCII-only

all other bots get their memories roled back, right?

PhiNotPi

00:54

Yes

ASCII-only

io9.gizmodo.com/5847205/…

primer has multiple timelines apparently, so if you want full primer style i don't think one timeline is possible

PhiNotPi

There's actually a lot of unexplained what-ifs to Primer's time-travel system. I'm not sure that the movie is 100% consistent. I think there's a couple options: either I could attempt to iron out a lot of the inconsistencies in some way, or I can write my program first using some basic rules and see how it solves those situations.

Most of these scenarios involve things like the use of fail-safe boxes / the use of "overlapping" time machines, or taking a time machine back in time inside of another machine.

ASCII-only

unrealitymag.com/wp-content/uploads/2011/09/primer-chart.jpg full size

wait, brb looking at. chart

PhiNotPi

I've seen that chart before, and I think it's the best thing to go off of.

ASCII-only

so looks like a new timeline is created on the earliest time travel

and simultaneous travel is allowed

PhiNotPi

01:10

By simultaneous travel I assume you mean cases where both Aaron and Abe travel back together?

ASCII-only

yeah

PhiNotPi

Because I noticed that, and there's no way to really explain how they both ended up in the same timeline when they travel in separate machines.

ASCII-only

make it turn based, if they enter and exit on the same turn create new versions

if one exits later it disappears

otherwise let the machines be able to be entangled or something

or else that should the only place where the timelines branch, abuse of that would be pretty annoying though

PhiNotPi

I think there's a way for both people to get on the same timeline without having any kind of entanglement... but it involves an intermediate timeline where one of the pair arrives but the other doesn't.

I think I might stick to the idea that time machines that are entered at the same time arrive on the same timelines.

Some other unanswered questions involve what happens if you enter a time machine that somebody else exited earlier.

ΛεγίωνΜάμμαλϠΨΠʹ

01:29

Idea for self-consistency:

Every step of the game is recorded.

When a bot travels back in time, the game is rolled back to the previous state, with the addition of the future bot.

If the original bot reaches a state where it is impossible to travel back (i.e. dead, round end, etc.) then the state is rolled back and both original and future bots are destroyed.

If the original bot still travels back to where the future bot came, then self-consistency is achieved and the round continues as normal, with the future bot replacing the original bot.

@PhiNotPi @ASCII-only Feedback?

(Additionally, this system only requires a single timeline.)

PhiNotPi

Seems good. What should the rules be regarding re-use of time machines / taking a time machine inside of another one / communication between copies to take information back to the past?

The last of those being the most important question.

Your system isn't actually very Primer-like, but I think that's okay (pretty sure a faithful implementation is impossible/infeasible anyways).

ΛεγίωνΜάμμαλϠΨΠʹ

The thing with future communication is that any information will be invalidated after the rollback which includes the future bot. (Also, the original bot completing the loop would have to carry the same information.)

But yeah, I've never actually watched Primer, just know that it includes boxes and multiple timelines and a backwards plot

ΛεγίωνΜάμμαλϠΨΠʹ

02:19

@PhiNotPi An optional modification:

On self-inconsistency, instead of destroying the bot, the game should be rolled back to the original travel that started the loop, and the travel fails.

(Note that this will require storage of the states right before time travel.)

PhiNotPi

That could work.

Transcript for