Just change how the algorithm sees timetravel.

If someone is going to timetravel from t=2000 to t=1000, it was predetermined. So you can change the algorithm, so that he "just appears" at t=1000 and disappears at t=2000 (and reappears at t=2001 if he travels back or something).

This will depend on the way you interpret causality. It's not the same from the point of view of someone trying to reverse engineer it, than from a "god" setting up a configuration. Also if there should be a past with no time travelers that lead to the past with the time traveler. Even so, we don't know the function $f(x)$ that defines this universe, but we can assume it's extremely complex, with lots of outputs.

We could think an output of $f(x)$ as providing a map of every person on Earth and their hair color. I will assume that time is quantized.

At $t=997$ there's someone with black hair at (1,1), a blonde at (3,5) and a readheaded at (11, 96).

At $t=998$ there's someone with black hair at (1,2), a blonde at (2,5) and a readheaded at (11, 96). This is because the first two people moved from the previous position to the next "square". The third one didn't.

At $t=999$ there's someone with purple hair at (1,2), a blonde at (1,5) and a readheaded at (11, 96). Well, the first one was dying their hair at a the hairdresser's.

At $t=1000$ there's someone with purple hair at (1,2), a blonde at (0,5), a readheaded at (11, 96) and a Gallifreyan at (3,14)

Wait, where did that last entity came from? There's no nearby entity that could move there. The other changes can be easily be explained with physics by someone doing physical action. However, $f(x)$ doesn't require that. It only describes the state at a given $t$. From $f(x)$ calculation, it only tells us it appears from nowhere. As this is a deterministic universe, something will be forced to happen so that such state (a time machine from $t = 2000$? A wormhole?), just like the blonde is forced to move (3,5), (2,5), (1,5), (0,5).

Similar to Robyn's answer, but with some different reasons.

Alice travels back in time. In your deterministic universe, the fact that she does so is determinable from the laws of physics and the initial state of the universe. Not only that, but everything she does when she goes back in time is determinable from the initial state of the universe.

That means all the information needed to calculate the results of her visit is already present in that initial state, and therefore is also present immediately before her arrival. That is, the deterministic calculation of the "next state" of the universe is able to calculate from the past information only that a time traveler appears at this point in time, and go on to calculate every effect of the event.

In a deterministic universe, the future is not some unknown thing that cannot be accounted for. It is a fully knowable thing whose impact can always be calculated.

I don't see why it cannot be calculated, as long as the machine/human/god doing the calculation has infinite time and resources.

If backward time travel is possible, you have a feedback loop. It makes the math more complicated, but not impossible.

Until the first time travel, the process go sequentially: first t=999, then t=1000... then t=2000. Once Alice travels back in time from t=2000 to t=1000, you need to go back to your state in t=1000 (now t=1000b) and keep going until t=2000. There, Alice (or Bob) will again travel back in time, adding a new input that needs to be added to the state in t=1000b.

After a few iterations, the time travel in t=2000h will be exactly equal that the one in t=2000g, and no new input will be added to t=1000g. The function has converged and the math can go forward to t=2001.

It will always converge, even if it takes several millions of iterations for each jump in time. Alice will travel back in time and do the actions required to influence her to go back in time and do the exact same actions. In this state of the universe, every action is deterministic.

Paradox are not possible: after enough iterations, the universe will converge.

It's simply an extra consistency constraint on the system

A system of equations (and/or constraints) can have any number of solutions, be it zero, one, five, a billion, or infinite. "Time travel consistency" is simply an extra equation or constraint.

A deterministic universe needs a set of constraints with exactly one solution. Adding a time-travel constraint simply means that certain Garden of Eden configurations do not yield valid universes. (This may be the case even without considering time travel, depending on your constraints. You might for instance say that black holes aren't allowed.)

One may argue that this means you can't calculate $f(t+1)$ from $f(t)$, but you can. It's just a more complicated calculation that potentially needs to basically work out the entire future of the universe just to give you the next instant of existence.

To give a concrete example, let's suppose we have a sequence $x_0,, x_1,, x_2,, x_3, ... x_n $, where all numbers are below some large number (say 1 billion), and each element in the sequence is the prime number with the largest digit sum that has not yet listed. For example, 7 would come before 23 (because 2+3=5) which would come before 113 (1+1+3=4).

In order to find the "next" number in the list you have to find all numbers in the list, and thus all future states of the universe. But the next number is always unique!

But in a physical universe isn't it impossible to satisfy all constraints?

You may be wondering, if under "normal conditions" a step from $t$ to $t+1$ follows certain rules, then how come when a time machine pops out of nowhere, are these rules not violated in comparison to the time machine not appearing?

Well the trick is in the word largest that I used in the example above. (As in, largest digit sum.) That sort of word creates a flexible constraint—one that implies uniqueness but doesn't force a particular solution.

Allowing time travel in your universe slashes valid Garden-of-Eden states by a mind-boggling amount. Only universes where a "time loop" satisfies all constraints will be valid. So, there is no universe where one could successfully go back and kill their proverbial grandfather—but it also means certain new universes become possible (like when your future self comes and prevents your own death.)

The problem here is that you need to use an iterative calculation. Once you figure out that Alice will go back 100 years you need to back up your calculation 100 years, add Alice and recalculate those 100 years. Note that this will get exceedingly complex if there is any substantial amount of time travel. That doesn't mean it can't be calculated, though.

Who says time is one-dimensional?

If time has more than one dimension, you can allow bi-directional time travel along some of the axes, as long as one only allows one-directional travel. Consider a universe with two time dimensions - one which allows bidirectional travel ("time") and one which doesn't ("meta-time").

As long as time travel takes some amount of meta-time, this removes the circular dependencies. t = 100, m = 100 doesn't depend on t = 200, m = 100 anymore - but it doesn't depend on t = 0, m = 100 either! Instead, those all depend on t = 100, m = 99, and t = 100, m = 101 depends on all of them in turn.

This is actually a pretty common approach, though it's usually not very explicit. It usually hides behind terms like "timelines" or occasionally "parallel universes".

You are looking from the wrong point of view I believe. The world's time is not the same as the time travellers time. Let's say all of the elements in your world equation can be defined as some f(t), where t is their personal time, as in the age of the most fundamental particles that constitute the elements. So W(t) = f0(t) + F1(t)+ ....and so on. Usually the value of t will be same as value of t for world. Now when a person x from t=11 travels to t=9 from the frame of reference of the world, the world equation becomes W(9) = f0(9) +F1(9) +fx(11)+.... Do you see the problem now ? Your equation now has an extra element. And that means W(9) now has two values. Two distinct branches of time, one in the time travellers past, and one in the time travellers future. I don't know how to put that into equation but essentially, you should either gonwith the multiverse, where the world equation branches off with a new element in it, giving each branch its own formula. Or you can modify your equation to be self consistent by adding all future elements into the equation as well. So the equation not only takes into account the past states but the future states as well. Kind of like W(t= tx) = sum( f0 | 0 to inf) + sum(f1 | 0 to inf) ..… repeat that for F2, ...fx. where fx are the fundamental particles. As long as nobody time travels, the value of f will become 0 for t > tx, but when they do, the equation can handle it. Basically laplace's demon knew someone will travel back from future and hence already took it into account.

Unpossible

Your function is impossible:

Starting from an initial garden of Eden configuration at time t = 0 every configuration of the universe at a future point in time can be calculated by a function applied to the configuration of the previous point in time.

The reason is that "previous" is an infinitely long time away once you introduce a loop. Therefore, there is no "Garden of Eden" configuration from which you can bootstrap your configuration.

Counter Example

Marty meets Doc Brown in 1985, and then jumps back to 1955. The sequence up to 1985 is causal and deterministic. However, as soon as Marty jumps back, you now have a problem. Future Marty is a new cause of events between 1955 and 1985 that you already computed. Now, let us suppose that one of Marty's hobbies in 1985 is solving the Rubik's Cube. On his jump back to 1955, he happens to have a Rubik's Cube in his pocket. Suppose further that Dr. Rubik happened to be visiting Hill Valley for a conference, and walked past Marty sitting on a park bench, working on his cube. He pauses and watches Marty for a few minutes, then returns to Hungary, working out the mathematics to convince himself that a solution was possible. Since he is an architect, not a mathematician, he is unable to prove that the cube is solvable, and gives up on it for 25 years. Then, in 1980, while replacing a light bulb in his toilet, he slips and falls and bumps his head. At this point, the solution to the puzzle appears to him like a dream, and he visualizes the mechanism of the cube in a flash, which he quickly draws and subsequently licenses to toy manufacturers. What we didn't say is why Marty jumped back to 1955. When Doc Brown was showing Marty the flux capacitor, Marty was solving the cube idly without looking at it (Marty was able to solve the cube blindfolded). Doc wasn't ready to use the DeLorean yet, but Marty's hand slips and he almost drops the cube. As he reaches to catch it, he bumps a switch which activates the flux capacitor. Doc realizes that his precious plutonium will be consumed if he doesn't go now, so he tells Marty to drive the car up to 88 mph, at which point they jump to the past.

Analysis

Now, the version of determinism you describe can be modeled as a function, $F(C_t) = C_{t+1}$. That is, the function $F$ applied to the configuration $C$ at time $t$ produces the configuration at time $t+1$. In particular, the proximate cause of an event in configuration $C_t$ must exist in $C_{t-1}$, and the ultimate cause in $C_s$, for $s<t$. Furthermore, you have defined $C_0$ as the "Garden of Eden".

We know that there are configurations in which the Rubik's Cube exists. Therefore, it is natural to ask: "Which state contains the ultimate cause of the Rubik's Cube?" We know that Dr. Rubik invented it, and so we might say that the incident on the toilet is the ultimate cause. But we know he was thinking about it for 25 years, and he actually saw it before he invented it. So we could say that the cause was when he passed by Marty. But Marty only had a cube because Dr. Rubik had invented it, so we could say that the ultimate cause was when Marty jumped back in time. But Marty had the cube before he jumped back, so we should say that the invention of the cube was the cause of the invention of the cube.

Let us call the moment of invention in the bathroom $C_i$. The point at which Marty jumps back to the past is $C_j$. The moment when Dr. Rubik is exposed to the idea of a cube by Marty is $C_e$. We know that $i<j$ because Marty only jumps back to the past because he bobbled his cube. And we know that $e<i$ because Dr. Rubik did not invent the cube until he had already seen it. And we know that $j<e$ because Dr. Rubik didn't see the cube until Marty had jumped to the past.

If history is well-formed, then for any configuration $C_x$, there should be a finite number of applications of $F$ starting from $C_0$ which arrives at $C_x$. Or, going backwards, we should be able to find the cause of any event by searching backwards through the timeline until we find $C_c$ such that $F(F(F(...(F(C_c))...))) = C_x$. However, we cannot find $C_i$ above, the moment of invention, because we are stuck with $i<j<e<i$. The configuration $C_i$ must occur before itself, and thus be its own cause!

Conclusion

And herein lies the rub: time loops allow self-caused objects to exist. Since time travel itself violates conservation of energy, there is no limit to what objects may self-cause. This theme is well-explored in the German Netflix drama Dark. A wise, powerful dragon may suddenly appear because it whispers in the ear of a bioengineer on how to craft the DNA of the dragon and implant it into an existing creature, which causes the dragon to be born, after which time the dragon uses time travel go to back into the past and cause its own existence.

In particular, time travel breaks your function $F$. When $F$ arrives at $C_e$, the earliest point in the time loop, Future Marty appears out of nowhere. There is nothing the set of configurations $C_{<e}$ which explain Future Marty. Only the future configuration $C_j$ can explain his sudden appearance, but that is many configurations subsequent to $C_e$. And therefore, you have broken determinism at this point. At any moment, $F$ may as well introduce a dragon or a unicorn or raining fish teleported from another dimension. Time travel makes a mockery of determinism. Laplace's Demon becomes infinitely powerful, and also capricious.

Assume f(t) generates (t+1).

Therefore:

t1 = f(t0)

t2 =f(t1) = f(f(t0))

Etc.

traveller x travels from 7 to 5. Traveller is based on t7, so denote it x(t7)

We need to insert this into the calculation for T6. Thus:

T6 = f(t5, x(t7))

T7= f(f(t5, t7))

This will presumably require some kind of time-based calculus to compute, which may or may not be easily solved, but can certainly exist.

If It Makes Sense We Can Simulate it

There are really two questions here:

(1) Is This Universe Possible?

(2) Can it be Simulated?

For (1) you at least need some time travel rules to avoid the Grandfather paradox and similar. Let's suppose you've done that and focus on question (2)

To answer (2) here is a baby example. Suppose there are 100 time slots and a single instance of time travel. At time 80 someone travels back to slot 20. You want to see what happens on time 50. This is how you do it:

Work out 1,2, . . . , 80 as usual based on the deterministic update rule.

Now you see there is a time traveller who goes back to time 20. Copy that traveller's mental state (which encodes all the decisions that will ever make). Now go back to the previous simulation of slot 20 and insert the copy of the traveller.

Now work out the new 21, 22, . . ., 50 based on the old 20 with traveller inserted and the deterministic update rule.

Reverse engineer the seed.

What you describe is the same problem faced by people who want to determine the seed used to generate a Minecraft world. In Minecraft a seed number is used to generate the entire world. Minecraft will pick one at random or you can give it one. A given seed will generate the same world each time.

https://minecraft.gamepedia.com/Seed_(level_generation)

World generation

Whenever the game has to generate a new world, it calls upon an algorithm. This algorithm outputs a pseudo-random value that is then used to determine the characteristics and features of the world. However, the algorithm always outputs the same value each time for a constant starting point (seed). This is why seeds exist — to generate entirely different worlds, consistently each time, from single values.

A world's seed is set when that world is created. By default, it is decided automatically, but it can also be set manually. Set and reuse a seed to replay that world, or use a known seed to play the same world as another player.

If you could determine the seed of a world you could know it completely. In a competitive map, a player who knew the seed could generate a copy of the map and study it at leisure, so gaining a competitive advantage. For your question. if you knew the seed of the world you could know its state at any point in time.

People try to figure it out. The below text is from a programmer who tested one seed after another ("brute force") and used the appearance of several unusual features to narrow down the list of candidates.

https://www.reddit.com/r/technicalminecraft/comments/7idgzx/seed_reverse_engineering_survey_of_approaches_and/

Seed reverse Engineering -- Survey of approaches and a structure-based Algorithm.

This post contains information I've dug up on the various ways to figure out the seed of a world without having direct access to the seed. Also I introduce my own approach to the problem below -- a GPU accelerated brute force implementation which searches for the seed using structures such as ocean monuments.

The code I wrote is an ocean-monument based solution for finding the seed. Although if I remember correctly, only very slight adjustments of some of the constants should be needed to adapt this to other structures such as villages... About 6 or 7 monuments provide sufficient information to work out the seed. The RNG check for whether a ocean monument can spawn in a certain chunk is significantly more complex than a slime chunk, and involves 4 iterations of the Java LCG... I implemented a straightforward brute-force approach in CUDA. On a Titan X Pascal, about 22 billion seeds are tested per second, so 248 seeds can be searched in just over 3.5 hours. I'm quite happy with this result, because it shows with a good implementation, a brute force solution doesn't need to take forever.

You could do this for your world - if you can run simulations. The programmer above used the appearance of "ocean monuments" - unusual structures - at given sites to narrow down the list of candidate seeds for a given world. If your world has Yosemite and Devils Tower at time CE 2020, see what seeds generate a world with both. Once you have a short list you can look at more features to narrow it down to just one.

In my thinking about this problem, there is no reason that you cannot have time travel in a block universe. It would be a poor kind of time travel but it would be time travel.

For example, X in year 2000 devises a means to travel back in time to year 1000. In your model, everything in year 1000 is determined absolutely by the year 999. In my block universe, the computation is not so linear. My computation would encompass all of time, including incursions from the past or the future. In this case, X has no free will. He has and always will make the journey from the year 2000 to the year 1000. Thus, the universe is not strictly linear in how sentient being perceive time.

The writer could devise all sorts of journeys through time in such a universe. Indeed some of the time travel stories that I have read depend upon the inevitability of the twists and turns. X travels to the year 1100 where he sees Y die. Later (in X's timeline) he travels to the year 1099 where he meets an earlier Y and imparts the precise information that leads Y to their death. Sadness and despair all around.

If someone travels from t=2000 intending to go to t=1000, they actually go to a t=2001 state, which is calculated by the algorithm using what it already knows about t=1000, and internally looks just like t=1000 did except with the addition of the time traveller. You basically recycle t=1000 except with something changed by the state at t=2000, which is exactly what you want time travel to do. So you’ll end up with a lot more clock ticks than are necessary just to account for the perceived elapsed time within the universe, since you need to effectively roll the clock back every time someone travels to the past.

You’ll either need a lot of memory (so that you can hold every state in memory for ever) or a lot of CPU time (so that you can recalculate earlier states from scratch from the garden of Eden configuration when required).