Mariposa – A programming language with time-travel
github.com
github.com
(define x 1)
(define t (now))
(display x)
(at t
(set! x 2))
Also FWIW here is the definition of now and at that I had before I decided to stop:
(define-syntax now
(syntax-rules ()
((_)
(call/cc
(lambda (k)
(lambda (at-body) (at-body) (k #f)))))))
(define-syntax at
(syntax-rules ()
((_ instant body1 body ...)
(instant (lambda () body1 body ...)))))
It's an interesting problem, but one that I think is ok not to be able to solve in Scheme.
uh, case in point, that hypothetical closure would have some difficulty crossing module boundries (and that's assuming it gets away with re-writing top-level define forms), but still nothing technically incomputable, just supremely ill-advised and still closer to a reimplimentation of mariposa's semantics than a truely native concept emerging out of the continuations system
To address this, we implemented a similar concept in ThetaML for defining stochastic processes, financial instrument payoffs, and trading strategies. We introduced the
theta t
S = 1
loop inf
theta @dt
S = S * exp( (r - 0.5 * sigma^2) * @dt
end
Example:
1: model EuropeanPut
2: % This model returns a simulated European put option price
3: import S “Stock prices”
4: import CUR “Discount factor”
5: import K “Strike price for the European put option”
6: import T “Time to maturity in years”
7: export P “European put option price”
8:
9: P = E(V_CUR!)
10: % T years pass
11: theta T
12: % at maturity T, the option payoff is discounted to time 0
13: V_CUR = max(K - S, 0) * CUR
14:
15: end
For those interested, you can find more information in the ThetaML Handbook: Here is the ThetaML Handbook: https://www.thetaris.com/doc/book-2012-thetaml-Handbook.pdf
More formally: "Temporally Quaquaversal Virtual Nanomachine Programming In Multiple Topologically Connected Quantum-Relativistic Parallel Timespaces... Made Easy!"
Have you considered this approach to apply to more than time? There is all sorts of conditional-based divergence code may take beyond time.
1) Compile with "time travel" AKA point-in-time state memory enabled (and accept slower code execution).
2) Compile without "time travel", AKA standard compilation -- for much faster code execution.
3) Compile such that some, but not all sections of code will selectively save their exact state at points in time, and can be "time traveled" by a debugger -- but only for those sections of code explicitly marked.
4) Compile such that "time travel" could be selectively turned on or off (may require dynamic function recompilation at runtime) for any function or specific lines of code, as needed, during runtime!
Anyway, Mariposa looks like a step in the right direction -- and really cool!
I've written about this before. Instantaneous data transfer with zero lag is theoretically possible through use of quantum entanglement. You can use this same technique to build a doomsday clock similar to the film "Tomorrowland".
No, that's a common myth about quantum stuff.
The entangled relationship can't be used to transfer information on its own. Whatever you sample from the "instant parts" can only be checked and understood after additional context arrives in a conventional way--limited by the speed of light and the flow of time.
https://www.space.com/41968-quantum-entanglement-faster-than...
There are also other quantum things that the youth of today need to be educated on:
11 years ago I wrote some examples of how password cracking would look like using such setup. https://marak.com/blog/2013-05-13-time-loop-software
I say through "through use of quantum entanglement" as glossy term for reader. Crystalline quantum circuits are not really existing yet so is all scifi.
I won't be able to repsond to further posts in this thread. Cheers.
Time-loop logic does not violate causality. We are able to retrieve the answer instantly because we have committed to spending sixty seconds in the future calculating the answer and sending it back.
Maybe quantum superposition is just the universe compiling.
Then FTL communication opens up an enormous can of causality-worms.
> The principle asserts that if an event exists that would cause a paradox or any "change" to the past whatsoever, then the probability of that event is zero. It would thus be impossible to create time paradoxes.
Computer says no.
I hope you wrote a correction wherever you wrote this. Quantum entanglement can not transfer information by itself (because of the no-communication theorem) therefore any data transfer protocol that uses entanglement must also use some other form of communication (e.g. classical communication), and therefore is at most as fast as your other communication method is.
Now suppose that the first party resolves to go back in time and kill his grandfather unless the bits he measures are precisely the message he wishes to send. The universe can't tolerate the paradox, so it is corralled into the only non-paradoxical outcome: both parties read the desired message. Something like that, anyway.
Obviously these are rather different. In fact I feel like the entanglement doesn't even help in the time-travel protocol. If you want to send messages instantly and you can send messages back in time, you can "just" send yourself the message distance/c seconds in the past and send it then. Some messing around let's you arrange for it to arrive at exactly the time you want to send it in the future.
So it's a kind of circular logic, or at best an observation that having one kind of supernatural magic power would let you cause another kind of supernatural magic outcome.
In this case, if only I had a time machine I could break the speed of light. (Or possibly vice-versa.)
https://dl.acm.org/doi/pdf/10.1145/331119.331415
https://www.researchgate.net/publication/3557566_ChronologZ_...
x = 1
t = now()
print(x)
at t:
x = 2
The semantic is confusing at first but think of it like now() took a snapshot of your program and "at t" went back and modified it.
The compiler will evaluate the entirety of your program before execution, and sequence things as directed.
If you're wary this could lead to incomprehensible programs, remember:
It should be understood only as an exploratory game.
I think Mariposa should be added to esolangs.org
So theoretically your debugger could also travel in time (like the Visual Studio TTD feature I guess).
Does Mariposa attempt any garbage collection?
It's interesting you can pass ticks around as a function parameter.
1. https://hackage.haskell.org/package/tardis-0.4.4.0/docs/Cont...
2. https://rosettacode.org/wiki/Water_collected_between_towers?... (see the "see also" section for a Tardis implementation)
Sincerely: what is the pragmatic value?
[edit: NM, end of the page...
> Semantics and correctness of implementation It is not obvious how the Mariposa language could be given a formal semantics. Since there is no specification of its semantics, it doesn't even make sense to ask if the implementation is right or wrong. However, we are sure that the implementation is incorrect for almost any conceivable semantics. It should be understood only as an exploratory game.
]
Frequently these esoteric languages have very interesting purposes.