# Minimum computational power for ad hoc navigating the solar system

Imagine a world (or rather a solar system) where in its history there has been a war with emergent AI's

There are very strict laws governing the speed and complexity of computer systems

However because of the very depleted state of raw materials - (imagine 1000's of years, even after AI emergence) - society has been forced to push their technology as far as they dare.

I'm aware that the Apollo missions had a scary low level of tech. However they had a very rigid mission and a very large team only a few (4-5) seconds away as backup...

What level of computational sophistication (and human skills) would be required to navigate without external help, and would also allow for on the fly "mission" planning, at extreme distances such as the ort cloud ?

(No communicating (or scanning/radar) faster than the speed of light!)

• Where are we starting from and going to? – HDE 226868 Nov 16 '14 at 23:06
• As mentioned in the question, usually earth / ort cloud return but equally ad hock intermediate destination which might include planetary rendezvous - obviously this assumes some kind of hibernation technology – Chris Camacho Nov 17 '14 at 0:15
• If you have infinite fuel and a telescope, just point at the planet and steer by eye. – Oldcat Nov 17 '14 at 22:54
• @Oldcat If one has played KSP, one knows this can actually be done... As long as all you need is ballpark. :P – Arkenstein XII Jul 29 at 2:40

(Note: I'm assuming low-efficiency, high-thrust engines similar to today's chemical rockets. If you can manage a constant 1G for the entire duration of the trip, or if you're using a high-efficiency, low-thrust system like an ion drive or a solar sail, navigation becomes very different.)

Navigating within the Oort cloud for short-duration trips (say, less than 1% of an orbital period) is easy: the gravitational influence of everything out there is weak, so a first-approximation solution to any navigation problem is "point your nose at the target, then fire the engines" or "point your engines at the target and fire them". You may need a mid-course correction or two, but those will be minor.

For longer travel times (up to a full orbit or so), you're looking at what is effectively a set of simple two-body orbits: the only gravitating body worth worrying about is the Sun, and all orbits can be treated as elliptical. Yes, you've got other influences such as Jupiter or nearby stars, but everything moves slowly that far out, and a course correction every year or two isn't too hard or fuel-intensive.

For multiple-orbit travel times, the system starts verging on the chaotic and you'll want powerful computers to figure the most efficient path, but I doubt multi-thousand-year missions are on the agenda.

Travel in stronger gravitational fields is harder to compute, but generally there's a single dominant body. If you've got time and fuel to spare, you can treat almost any route as an orbital rendezvous and fly it without any computations whatsoever.

In reality, however, the increased efficiency of better trajectories is worth the effort. In a computer-free world, navigation is likely to be done with slide rules, nomograms, and tables of standard transfer orbits, all of which can be prepared once and then used for many trips. Gravity assists will be rare, generally used for trips that can be planned well in advance (eg. the initial leg of your Oort cloud mining expedition). Fancy maneuvers like the "spaghetti trajectory" used to put ISEE on a path to encounter Halley's Comet won't be done except for rigidly pre-planned missions.

• nomograms! excellent that will fit in well with the almost steampunk space age I'm envisioning! – Chris Camacho Dec 18 '14 at 14:31
• I thought the question involved Earth to Oort cloud and return. This requires much more challenging orbits than just drifting around at the Oort cloud distance all the time. – Innovine Oct 13 '16 at 9:16

Minimum computational power for navigating a solar system is zero (in other words pen and paper).

First, even if the civilization have not discovered a theory of gravity and Newtonian mechanics, it's possible to predict the orbit of planets very accurately due to the orbits being very regular. Kepler did this long before Newton provided us with tools to calculate orbits from first principles. Indeed, Kepler's calculations were one of the foundations that enabled Newton to formulate a theory of gravity.

Yes, calculating it this way would potentially require several years to calculate an orbit. Which would at first glance make it useless for navigation. But you really only need to calculate the motions once and produce a table or chart from which simpler calculations can be carried out to solve navigational problems.

Once you have a theory of gravity you can easily solve two body problems to calculate a planet's orbit around a star then apply it again to calculate your flight path in relation to the planet. Or use the restricted three body problem to solve your flight path in relation to two bodies such as a planet and one of its moons.

Solving n-bodies is computationally intensive. However, a 1kHz CPU is more than adequate to run an n-body simulation in almost real-time (remember, real-time is slow, it takes our planet 365 days to make one orbit). My old 20MHz Mac ran a 2D n-body planetary simulator at about 10 million times faster than real time (assuming the animation draws a planet orbiting its sun every one second, then 365 days divided by one second is 30 million).

Once you get closer to a planet or a moon you can revert to 2 body calculations.

See the Wikipedia articles on the calculations I mentioned above for a better idea of the difficulties involved:

http://en.wikipedia.org/wiki/Gravitational_two-body_problem

http://en.wikipedia.org/wiki/N-body_problem

I've read several old sci-fi stories where planetary navigation was done by the human navigator using pocket calculators. I guess back then people didn't consider letting the computer do all the work. Indeed, computers and AI were often relegated to solving the really difficult problems like figuring out the meaning of life or making the perfect cup of coffee :)

There is however a tradeoff. The simpler your flight path the more likely it is that you'd be using a lot of fuel. Saving fuel requires planning complicated (and slow) flight paths using gravity assists. You can use this fact to give different factions different advantages. The ones with more resources will have less incentive of increasing computing power. The ones with more computing power need more resources etc.

Actually, if you want to read more about humans solving those problems, Heinlein (and his scientist wife, can't remember if it was the first or the second) both did some navigational problems in order to get one sentence in one of his novels (he had the wife do it separately in order to double-check his work). It wasn't fast, but it also wasn't years. You'd probably be able to get it done even for on-the-fly stuff. I think that was in Expanded Universe. In any case, he was telling this to someone in like, 1960-1970? And they were like, why didn't you use a calculator. And he was like, this was before those were invented.

Also, for your scenario, you just over-prep the ships. They get more fuel and more power than they need, so that they can deal with mistakes that happen when calculations are off, or when you need to suddenly dodge micrometeorites.

More importantly, you're going to need to use a lot more fuel, and a lot more ship (hydroponics, life-support, etc, etc), in order to have the human brains on-board and functioning at all times (ie: 3 shifts a day) - instead of having computers monitor stuff and call alerts / wake up the humans.

Might be better to breed up space-beasts to collect your stuff for you. Or to run your ship's computational needs.

Also, human breeding. You'd breed up mentats or lightning calculators.

AI has been a hard problem to solve. You could probably get by with the computing resources we have now, since we've not managed to get AI even while trying. :D

Depends on the type of AI you've got.

• Note that pretty much all spacecraft rely on either ground observations or GPS for information about their position, so you would need the ability to take the extremely accurate position measurements yourself. If you have a good clock you might want to look at pulsar navigation (note the SEXTANT mission wiki mentions has become the NICER mission). – 2012rcampion Dec 18 '14 at 4:38

Our current CPU power is still well short of the singularity or even Restricted Intelligence, let alone full AI. So even a cautious civilization is likely to be able to run CPUs at least as powerful as we have today.

Those CPUs are entirely capable of calculating orbital dynamics, navigation, etc.

In order to prevent the emergence of AI then it isn't really the hardware you need to limit, it's the software. A computer can run as fast as you like but if all it's doing is a well defined and structured thing (for example a word processor) then it will never develop intelligence.

What needs to be limited is machine learning, programs that modify themselves, etc.

To improve performance of computations while preserving ban on AI, you can have Analog computers capable of performing one function but no other (safe from AI growing too much power). And slide rule (with pen and paper) is pretty efficient for calculations.

Note: I haven't included communication with other humans in my answer, I'm assuming the ship being at the Oort cloud cannot communicate with other ships.

Context

It's possible for the human brain to solve these problems quite easily, as can be seen by playing Kerbal Space Program and the Apollo moon landing was achieved with roughly the computation power of a calculator.

Scanning

The question is, what does the computer need to know. Assuming it has a radar that can output 3D vectors of solid objects you then to store these vectors. You need to decide some resolution and range for the radar. The distance to the moon is 384,000km so we'll make sure the range is big enough to encompass that, let's say 400,000km. (I'm making the assumption here that you don't want your radar to be able to track as far as the Oort cloud, you just want to be able to process reactions to collisions.)

We'll want to be able to pick up fairly small objects on this radar and avoid them so we can split that into units, being practical the 67P/Churyumov–Gerasimenko comet we just landed on is about 4km accross, so we'll want to pick up on that. That means at maximum that we have 100,000^3 units of scanning data to store.

Assuming the positions are measured as integers that's 1.2x10^16 bits of data, or 1.5x10^15 bytes (That's 1500 Terrabytes!) if the entire field of view is covered in matter. The ship is probably not going to be surrounded by objects so we can give it some kind of buffer and say that it can store maybe 100 points, which is of course a lot less, about 150 bytes. Which is really easy to handle.

Control

That's just for the scanning data. My calculator can only store about 70 numbers which means it probably can't do what you want. Lets assume a minimal computer with 1Kb of RAM which is 1024 bytes. That's a bit more than we need so it leaves us with a healthy 874 bytes to play with.

What do we need to do with this? Here you need to consider the structure of the ship. I'm going to go with the simplest possible configuration (based on Kerbal Space Program missions):

• 1 Reactionary engine (3 degrees of rotation freedom!)
• 1 Thruster (1 degree of forward momentum!)

[This just includes motion stuff, I'd expect door, lights, air locks, life support etc to all be simply plugged into some power supply and left to run, turned on and off light light switches.]

We need to be able to control these and make calculations about how to move the ship. So we need to know a few things:

• Velocity (3D vector)
• Acceleration (3D vector)
• Rotation (Probably a Quaternion, 4D Vector)

These need to be pretty damn precise so lets make them big numbers and say that we need 160 bytes for these! So we're left with 714 bytes to play with.

Now we need to do some maths. Assuming the ship knows its own mass it probably only needs to do $F = ma$ and $F = G({m_1 m_2}/{r^2})$ a lot to avoid an object. It might also want to then store a few values about its positions after a move its going to make, validate whether or not that leads to crashing into another different object and try again. So we can add another 100 position values or 150 bytes bring us to, 564 bytes left.

These remaining 500ish bytes of RAM must simply contain some basic logic about the process I described above.

1. Look ahead some amount and predict a crash
2. Try a move and see where it takes the ship
3. If that's no good try another maybe in the other direction
4. Try and correct movement towards some target vector if the ship has a destination

All of this can achieved with very little memory.

Processor

I don't know a lot about processors, but these calculations use very small volumes of data. My calculator lags when I press the button and we don't want that, so something in the range of 100+Mhz would probably be okay.