clearing bits far away from computation

[Bear]

I'm still not seeing the advantage.

Scenario A: Do your computing. It generates waste heat. Transduce the heat into a cool rock and eject a warm rock. (or, you know, radiator fluid or whatever)

Scenario B: Exactly the same, except with technobabble and reduced efficiency.

Seriously, how is dispersing the entropy of computation, by converting it into heat and using a thermally conductive medium, more effective than dispersing the entropy of computation, directly as heat using a thermally conductive medium?

[Bob Jenkins]

I'm still stuck on the mass distribution / stability of the central core. I'm getting closer to being able to simulate it, I have a high precision floating point library and interpolation working now.

I've got interpolation of the attraction of rings to rings working, and I have an orbit simulator again (in C++), but haven't added rings attracting rings to the simulator yet. I found a way to stabilize my doughnut-shaped Dyson swarm so that precession doesn't hurt it ... mass in an inner orbit makes it precess one way, while the mass of the swarm itself makes it precess the other, so they can be balanced. The central core of the design above is a bunch of nested swarms. It's looking like having it metastable is possible. I had expected it to need constant energy expenditure to correct precession, but no, it probably only needs monitoring and stationkeeping.

[stevebowers]

How about light pressure and solar wind?

Could the processing units preferentially emit waste heat outwards, which would cause a small amount of light pressure inwards to counteract the light of the sun?

[Tachyon]

I'm not sure what you mean by "swapping bits", but writing a bit requires joules per bit, and is an irreversible process.

Replacing (x,y) with (x, y XOR x) is reversible. It is its own reverse, because doing it twice yields (x, y XOR x XOR x) == (x, y).

Yes, and to perform the XOR operation you must perform a write, which consumes energy as noted above. Your "reversible" operation has consumed energy to perform the two writes. If it didn't, then you didn't actually perform the XOR (which is typically done by an XOR gate).

So this is a reversible process: (x, y) -> (x, x XOR y) -> (x XOR x XOR y, x XOR y)==(y, x XOR y) -> (y, x XOR y XOR y)==(y, x). That's swapping bits. If you want zeros in the second bit, it's enough to be able to irreversibly clear the first bit.

This might be logically reversible, but it still consumes energy for each op.