Computation using Time Travel

Time Travel is one of the most fascinating subject I have ever encountered. Having spent an unreasonably large amount of time thinking about it, the following describes one of the ideas I had regarding how we can use it.

Consider for a moment that humanity has somehow managed to develop the technology for Time Travel, and confirmed that the universe abides by the Novikov Self-Consistency Principle. For the purposes of this discussion, you may assume (although the specific details of how it is done don't matter here) that this is done via a Wormhole (stabilized using exotic matter with Negative Mass/Energy), one end of which (through Time Dilation effects) lies in our future. Now, we can establish a communication link across this wormhole, which allows us to send data into the past or receive data from the future. Additionally, let's assume that we can transfer information over this link via two specific functions in a computer program:

void send(data) # Sends data back into the past.
data receive() # Receives data from the future.


Now, I propose that these two functions can be used to solve any computational problem in same amount of time it takes to check if a particular solution is valid. Consider the following code:

candidate = random_solution()
if solution_test(candidate) == false:
  data = receive() # Get data from the future.
  send(false if data == true else true) # Send data into the past.
print "Random Solution :", candidate


If we run an implementation of the above, we would find that the if-condition is always false. Why? Because the existence of any reality in which this were not the case would be impossible.

It would be easier to understand if you think according to the Many-Worlds Interpretation of Quantum Mechanics. Let us start out with the assumption that every possible version of reality simultaneously exists. Now, these realities can be divided into 2 groups: [1] those with correct solutions guessed, and [2] those with incorrect solutions. The realities in the first group would skip the if-block and print out a solution. The realities in the second group would try to execute the if-block, which tries to send data back into the past which is the opposite of what it had received. This is a paradox, which the Self-Consistency principle would prevent, and thus, the realities in the second group cannot exist (the corresponding wave-functions would eliminate themselves). One of the realities in the first group would be randomly chosen (as a result of the wave-function collapse, the results of which are uncertain) as the one we experience.

Now, the above algorithm works perfectly if we know for a fact that at least one solution exists for the problem. However, it does not take into consideration what would happen if there were no solutions. In that case, all futures would have a paradox in them, and thus, all of them would be impossible. To fix that, we modify the code thus:

if random_number(1,N) == some_constant: # almost impossible
  print "No Solution"
else:
  candidate = random_solution()
  if solution_test(candidate) == false:
    send(false if receive() == true else true)
  print "Random Solution :", candidate


Now, if N is small, the probability of the randomly chosen number between 1 & N being equal to some predefined random constant would be 1/N. Now, if this probability is large (closer to 1), the False Negative Rate (realities in which it would be incorrectly guessed that there are no solutions) would be high. But in case N is extremely large, the chances of the if-block being executed would be so small that essentially the only way it would happen would be if all possible futures in the else-block lead to paradoxes. However, I should point out that the probabilities of making the correct guesses here may themselves be so low that events that prevent the execution of the program itself (such as the explosion of the Earth for no good reason) may turn out to be more likely, but let's ignore that for now (because I haven't figured out a way to avoid that yet. I'm still thinking though). Assuming that the program's execution does occur, we want to make N as large as possible, to make the False Negative Rate tend to zero (0).

Now, if it were somehow possible (using methods unknown) to determine for certain that that there are no solutions to the given problem, we could use that to calculate optimal solutions to any problem instead of just random ones. The algorithm would be something like:

• Receive a solution from the future.
• Confirm that it is indeed a solution or else invoke a paradox.
• Randomly guess another solution that is better than the current candidate.
• If there is a better solution, send it back in time.
• Else send the current solution back in time.
• Use the solution as you need to.

The reason that the above techniques work is that a Closed Timelike Curve is created, which basically involves an event that causes itself (via a chain reaction that travels back in time). Consequently, we cannot iterate over multiple solutions by using results from other realities because the chances of getting correct information from another reality would be outweighed by the chances of getting incorrect information, and as this information is not being verified in this reality, a CTC can exist here. Consider the following example:

candidate, best = receive()
if solution_next(candidate) != null:
  next = solution_next(candidate)
  if solution_test(next):
    best = solution_better(best, next)
  send(next, best)
else:
  send(candidate, best)
print "Optimal Solution :", best


Note how there is no starting point in the above loop. You can never be completely sure about the data you're receiving. The so-called "best" solution may not in fact be optimal, as the only reality that will actually occur would be the one with the final solution being returned from the future. Every possible value of the "best" solution would be a valid CTC, and therefore, the above code would be equivalent to:

best = solution_random()
print "Optimal Solution :", best


We need to verify that it is indeed the optimal solution, but that verification would take as much time as actually solving the whole problem without using time travel, and so it is just as useless here.

Of course, all of this depends on the fact that we are able to execute these programs without bringing about the destruction of world, or something much simpler and far more likely such as the shorting out of circuitry that prevents us from running these programs altogether. But this system at least provides us with a way to obtain and use optimal results before proving that they are in fact optimal:

candidate = receive()
print "Optimal Solution :", candidate
solution_use(candidate) # Do whatever you need to using this solution.
best = problem_solve() # Conventionally solve it.
if candidate != best:
  send(false if receive() == true else true) # paradox
send(candidate)


Intelligence Agencies, Military Forces, Governments and Corporations with trade-secrets would be utterly screwed if their opponents got a hold of this technology. In fact, there is a proper ethical dilemma here: How much do we value our privacy? Even if possible, is it something (like WMDs) that should not be implemented? What do you think?

PS : Thanks to Kirtivardhan Rathore and Akshat Uniyal, who helped analyze the merits of these ideas (and many others which didn't make it here).