Spelunking CACM, vol. 1 (1958): Accelerating Convergence of Iterative Processes

For our first spelunking expedition, I skimmed volume 1 of the Communications of the ACM.

The first thing that I noticed about the earliest issues is that numerical algorithms dominate: numeric integration, minimizing errors, etc. If you dig around, though, you'll find a smattering of topics such as binary search in tables, as well.

The one that caught my eye this morning is Accelerating Convergence of Iterative Processes, by J. H. Wegstein of the U.S. National Bureau of Standards.  (ACM began as an American organization; I don't know when the first articles from abroad appeared in CACM, nor when it began to really view itself as an international organization.)

The first thing you notice, of course, is the layout and typesetting. It's almost a newsletter format, single column, not a lot of boilerplate or fanciness. That said, the typesetting is pretty solid, even if it now looks kind of dated. (One big problem is the intermediate quality of the scans, but given the volume of material that needs to be brought online, I'm forgiving on this.)

The figures appear to be hand drawn by a competent but not brilliant draftsperson.

The paper contains an acknowledgment that another researcher contributed Section 4 of the paper, so I wonder why he wasn't listed as an author. The main body of the text also includes a comment by the editor (Alan J. Perlis?) on a method for reducing the computational cost. The paper contains no references.

Okay, on to the content...

Iterative methods for finding roots of equations have been known for a long time; one famous one is Newton's method. They always depend on some assumptions about the nature of the function. In this paper, we are looking at roots of $F(x) = 0$. If the equation can be written as $x = f(x)$, then you're looking for a constant point (a kind of eigenvector or steady state solution?), and it can be found by iterating $x_{n+1} = f(x_n)$.  If that form doesn't work, then you apply some factor $\Gamma$ by way of $x_{n+1} = x_n + \Gamma F(x_n)$.

The author examines several cases, where iteration causes values:

1.  to oscillate and converge;
2. to oscillate and diverge;
3. to converge monotonically; or, finally,
4. to diverge monotonically.

The main point seems to be an adaptive method for finding the factor $q$ in equations of the form

$\bar{x}_{n+1}=q x_{n}+(1-q) x_{n+1}$,

using the above equation for $x_{n+1}$.

The claim is that many (all? seems unlikely, but that's the way I read the text) equations can be transformed from diverging to converging, and the converging ones can be made to converge more rapidly. The overall process looks like this figure, where steps 1 & 3 are used only on the first iteration and the whole thing terminates when the absolute error drops below some pre-chosen threshold.

The author then goes on to show some examples of convergence. It's not clear to me that this was actually programmed; the examples would be somewhat tedious but not too bad if done by hand, and I don't see any other indication one way or the other.

Overall, a representative article from CACM's earliest years, and I think a successful spelunking expedition. I already have a couple of surprising articles lined up from 1959 and 1960, so stay tuned!

Spelunking Communications of the ACM

 I'm feeling both a little random this morning, and very under-read as a general principle, so I'm going to start something.  We'll see how far it goes...

Communications of the ACM is the Association for Computing Machinery's flagship magazine. The modern instantiation is fabulous. Its history goes back to 1958 (some sources say 1957, but apparently v.1, no. 1 was Jan. 1958). It has evolved dramatically in its 63.5 years of existence, as the platform we take for granted has grown and matured.

Last night, I decided to go spelunking in the archives. This morning, I decided I'm going to try to review one paper from each year of CACM's existence. If I do one paper a week, this will take me a year and a quarter.  (But we know I'm easily distracted, so the challenge is, can I keep it up?)

I'll pick something, not at random, but not based on metrics such as whether a paper has been cited a lot or has a famous author, especially in the beginning.  It will just be something that catches my eye, and it likely will be something far from my own expertise, so there's a good chance my review will contain basic errors, so please feel free to comment and correct but not deride. After we get into the 1970s, we'll start to see more of the names I already know, and by the late 1980s, when I became an ACM member, very likely I'll pick some papers based simply on, "I remember reading that!" So, this is very much spelunking -- going into the dark, picking things up and examining them, tossing most of them back but finding a few gems.

So, starting this morning, I'm going to review a paper from 1958. Come along for the ride...

A #QuantumInternet Architecture Position Paper 

Rodney Van Meter 

2021/5/9

Okay, here's something I've been intending to write down for some years...a brief outline of my ideas for a Quantum Internet architecture, based both on our published works and some ideas that aren't yet published.  The tl;dr is

1. the Quantum Recursive Network Architecture (QRNA),
2. RuleSet-based connections,
3. a two-pass connection setup mechanism,
4. qDijkstra with seconds per Bell pair as link cost for routing, and
5. ??? for multiplexing.

Of course, a lot of this is covered in my book (Quantum Networking, available in the ACM online learning center, I believe, though just now I couldn't find it).  But quite a bit about our ideas has evolved since I wrote the book, and it's good to summarize them anyway. Importantly, this is not a full survey of history or current thought; this is my idea for how things should go.  I suppose you could call this my #QuantumInternet #PositionPaper.

See the AQUA group publications page and my Google Scholar page for access to some of these papers and to others.

First off, of course, it's important to recognize that there will be an internetwork, a network of networks. http://dx.doi.org/10.1109/MNET.2012.6246754 or, for an unfancy copy,  https://aqua.sfc.wide.ad.jp/publications/van-meter-networking-review-preprint.pdf.

There will be more than one network architecture, no doubt; but to build a true Quantum Internet there will ultimately be only a single internetwork architecture.

There are a number of key design decisions that must be made:

1. the nature of the fundamental service: Bell pairs?  measured-out classical bits?  qubit teleportation? multi-party graph states?
2. how networks will come together to make an internetwork -- what is the nature of the interaction?  (affected strongly by connections, below)
3. the multiplexing discipline for resources (n.b.: not for access to wavelengths; this is a higher-level, end-to-end concept): circuit switching?  time division muxing?  statistical muxing, as in the    Internet?  buffer space muxing?
4. nature of connections: entanglement swapping and purification (1G), or QEC (2G, 3G)? (affects internetworking)
5. both of the above points affect whether a connection requires state at each repeater/router
6. how connections are established
7. how a path or route is chosen through the network
8. all of the above affect choice of whether to try to do multipath for a single connection
9. security for the network

There are more, but those are some of the critical ones.  For more on these kinds of issues, (as well as a super-brief intro to quantum networking for those without the background), see our Internet Draft, hopefully to become an RFC soon.

On individual links, using memories at each end and photons to entangle, it seems pretty obvious to me that the fundamental primitive is the physical Bell pair (which we also call a "base entangled state").  Everything else builds on top of this.

However, that's made more complicated by the possibility of all-optical repeaters, an area we are currently researching. (See https://quantum-journal.org/papers/q-2021-02-15-397/ and work backwards from there.)  An especially tricky issue we are actively working on right now is how to terminate such connections and how to make them interoperate with other types of connections/nodes/networks.

I believe that end-to-end multiparty states (GHZ, W, graph states) are likely to be extremely valuable, but I think it's an open question whether they are part of the fundamental service or should be created and managed entirely by applications running at end nodes.  (In particular, I'm not at all sure what the APIs at the responders are like to make something like this happen.  What is listen() like in this case?)  At any rate, I think QRNA and our RuleSet-based approach can handle either connection-level or multiparty graph states as we develop it over time.

Same for multipath connections.  It's a pretty obvious idea, and sorry but I can't remember who first proposed them in print (Perdrix? Benjamin?).  My own opinion is that the benefits of multipath are likely to be minor, as a. often, the first hop will be the bottleneck anyway, b. asymmetry in the paths in the real world means that benefits will be minimal, and c. I assume there will be a lot of competition for resources on the net, and so the occasions when you can actually acquire the resources to do multipath effectively will be few.  Oh, and d. the software complexity is high.  So, I think it's doable in QRNA+RuleSet, but it's far down my list of things to work on.

So, let's stick with Bell pairs for the moment as both the fundamental link service and the *primary* end-to-end service.  If we build well, it will be possible to extend later.

That disposes of...let's see...point 1 in the list above.  On to point 2...

I think that the internetwork architecture should be a fully recursive system; we have named this the Quantum Recursive Network Architecture (QRNA), after Joe Touch's RNA.  (Joe collaborated with us on this.) Today, an idealization of the Internet is that it's a two-level system, with BGP as the external gateway protocol and your choice of internal gateway protocol (OSPF and IS-IS being two of the most prominent).  The reality, with tunneling having long been common, with switched Ethernets requiring a spanning tree protocol underneath even though they are nominally "link layer", and lately with the huge emphasis on virtualizing networks and services (e.g., network slices), is that the Internet has long been a multi-tier system with ad hoc interactions at each level.  Designing from scratch, if we do a good job, this means that they are all unified into a single system.

Of course, if you want, at your network boundary, you can run anything you want inside: you just have to match the semantics of the connection's requests where they cross your borders.

Today, in the Internet, when a packet arrives at your border, the implied semantics are for you to forward it across (for transit) or to the matching end node (for termination).  For the Quantum Internet, connections will have to be established in advance, with a certain amount of state.  What I envision is a connection request protocol where, in a multi-tier system, connections are for some boundary-to-boundary (for transit) or boundary-to-end node (for request termination) operations.  Presumably, for transit, what connection requests see is each entire network as a node in the graph at this level (i.e., top-level eBGP graph).  Requests, then, are of the nature, "Please give me Bell pairs of fidelity F=x between here and address 1.2.3.4," where the requester knows that at this level of the graph that 1.2.3.4 is the next hop toward the destination.

Therefore, it's the responsibility of border routers to rewrite the request to internal actions that will fulfill this goal.  Again, internally, it can be what you like -- but if you adopt QRNA internally, it can be creating a new set of QRNA requests that reach from here to the gateway on the other side of the network.

There's lots more to say on QRNA; see our original journal paper or discussion in my book.  Beyond this vision, there is still a lot of work to do!

Two down, seven points to go...

Multiplexing: Lucho Aparicio's master's thesis addressed circuit switching, time-division multiplexing, statistical multiplexing (like Internet best-effort forwarding), and buffer space multiplexing, where the qubits at each router node are assigned to specific connections but multiple connections can pass through,  getting assigned a share of the qubits.  We studied aggregate throughput and fairness, and found, somewhat to our surprise, that stat mux works pretty well.  Aggregate throughput is actually above circuit switching, because it does a pretty good job of allowing multiple areas of the network to be working productively at the same time.  What's more, as far as I am aware, this was the world's first simulation of a quantum repeater network, as opposed to just a chain of repeaters. See Lucho's SPIE paper or Lucho's master's thesis.

However, that said, those early sims were for small-scale networks. I think this needs to be studied in much more detail to assess robustness in the face of complex, varying traffic patterns.  In particular, I really fear that something akin to congestion collapse is possible, and is to be avoided.  We already know that connection state will have to be maintained at repeaters & routers; quite probably there will have to be some active management of resources here, as well.

This has to coordinate with routing, below.  Naturally, we want to avoid fully blocking muxing protocol if possible.

Oh, and one more point on this: given that early networks will be low performance, how do we prioritize connections?  Do we create a static priority scheme, based on...how much money people have?  Auction off time slots?  Use a fixed accounting/charging scheme and lower nodes' priority the more they use, like an OS multi-level feedback queue?  (Can you tell that I lectured on MLFQ last week?)

Point four: an internetwork architecture needs to accommodate 1G, 2G and 3G networks.  Although these designations address advances in dealing with types of errors as our capabilities improve, they do not necessarily correspond to time.  Nevertheless, 1G, using acknowledged link layer entanglement creation to handle photon loss and purification (quantum error detection) to handle noise and decoherence, will definitely be the first deployed.  (Indeed, Delft is getting there, one step at a time.)

So, we need an internetwork capable of interconnecting different connection architectures.  We have addressed how routers at the boundary can make entangled states that cross the borders. 

Even for first-generation networks, though, you have to have a mechanism for saying, "Okay, Bob, once you get a Bell pair with Alice and a Bell pair with Charlie, execute entanglement swapping, then send the Pauli frame correction to Charlie and a notice-of-entanglement-transfer to Alice," and "If you have two Bell pairs with Alice, both with fidelity less than 0.9, then purify."

Our approach to this is to define Rules that have a condition clause and an action clause, very analogous to classical software defined networking (SDN).  For a connection, each node is given a RuleSet that should comprehensively define what to do as local events occur (entanglement success, timeout, etc.) and as messages arrive.

This RuleSet-based operation is the heart of our work these days, and allows for explicit reasoning about how to achieve the maximum asynchrony in the network (rather than waiting for explicit instructions at every operation or attempts to make everything proceed in lockstep).  The best reference to date on RuleSets is Takaaki's master's thesis or our PRA paper on the topic.

I believe this RuleSet-based approach meshes will with the vision of QRNA.  Indeed, when combined with a rewrite engine at network borders, as described above, it should serve well as an instantiation of QRNA.

All right, that actually handles point five, as well; RuleSets and any qubits at the nodes that are currently assigned to a particular connection, well, that's connection state at each repeater/router. The scalability of this needs to be assessed, but I don't see a way around it right now.

(n.b.: as a network architecture aside, for the foreseeable future, there won't be any high-performance links; they'll all be low performance.  Therefore, there won't really be backbone, long-haul, high-bandwidth links, either; the network topology is going to have to be richer.  So there might not be huge numbers of connections passing through individual routers, anyway.)

So, point six, how do we set up connections...our approach is to use a two-pass system.  On the outbound leg (starting, appropriate enough, at the Initiator), you collect information about links and available resources.  The connection request eventually reaches the Responder, which takes that information and builds RuleSets for everyone along the path.  Those RuleSets are then distributed in a return pass, then the operation for the connection begins.

This has a few interesting points: a. it limits the amount of information each node has to have on hand about the entire network, b. it allows Responders to innovate (within the bounds of the RuleSet architecture), and c. it will work well with the border rewrites necessary for QRNA.

I have presented this approach in any number of talks (see, oh, for example, my 2020 virtual talk at Caltech -- there is a video file there as well as PDF of my slides), but so far it's only written down in an expired Internet Draft that I hope to revive, and in some of the documentation on our Quantum Internet Simulation Package (QuISP). 

Which brings us to point seven...how to pick a route.  Quite some time ago, we investigated a variant of Dijkstra's algorithm, which we inventively call qDijkstra.  We define link cost as "seconds per Bell pair of some index fidelity,"  e.g., seconds to make a Bell pair of e.g. F=0.98.  Including fidelity in the metric makes a lot of sense; a high data rate but with poor fidelity may be less useful than one with a lower rate but higher fidelity.  Thus, if your base fidelity is poor, you have to take into account purification, which automatically reduces throughput by half and more likely by 3/4 or more.  We compared (via simulation) the throughput of various paths with heterogeneous links, and found a good correlation with our calculated path cost.  Fidelity is actually too simple a metric, so the correlation isn't perfect, but we think it's good enough.

The biggest open question here -- and one of the things we are investigating -- is how to combine path selection with multiplexing/resource reservation.

Whew...let's see, we covered multipath above when talking about connections, so we're set there.

Bringing us to point nine, network security: in fact, we are the only group in the world looking at security of network operations for quantum repeaters. But this doesn't mean at all that we have a complete plan for secure operation of the Quantum Internet.  Fairly obviously, all of the protocols we've talked about above need authentication and tamper resistance; whether privacy is also required or useful is an open question.  Given the previous Internet (and, to a lesser extent, telephone network) experiences with lack of security in routing, accounting, DoS, etc., and the likely high cost of quantum connections, it seems pretty imperative to have a solid framework in place very early in the Quantum Internet, basically well before we have a truly operational network.  And, this ties into the muxing decisions as outlined above -- you can't have accounting and authorization without authentication.

Whew, that's a lot of decisions, and lays out a lot of work to do. And we haven't even addressed some important topics, like naming.

If you can't carry all that in your head, just remember the three critical points: a recursive architecture for internetworking, RuleSet-based connection operation, and a two-pass connection setup routine (outbound info collection, inbound RuleSet distribution).

And although there is solid work on routing and multiplexing, designing a system that will be robust at scale and that will serve us well for decades is a big, open issue. 

M42: November Orion, Revisited

 

(Click for a bigger view!)

I went back and re-processed data from 2020/11/22, used for this image. This time, I included the 10-second exposures, which is how I got the detail in the core of M42 that was blown out in the earlier pic.

I stacked 95x10sec exposures (with 15x10sec darks and the same flats I used for the earlier pic), then took that image and the 47x30sec stacked image, adjusted them so their histograms were similar, then stacked those two. It worked remarkably well; if you look closely at the two images, this one not only has more in the core, it has more detail in a few places, some of the stars are sharper, and importantly, the noise levels are substantially lower.

I think the optics & mechanics I used could still give a little more, if I shot at 200mm instead of 145mm focal length and took more lights, and especially more darks and flats. But I think this is pretty close to the limits of the data I have at this point.

Nebulosity Processing: A Few Comments on the Orion Photo

 Yesterday I posted a photo of Orion that I'm pretty happy with. I included basic technical notes, but here are some additional anecdotes on the image and processing.

Min Yun asked about the filter (digital signal processing, not glass) I used. This was done with Nebulosity 4.4's "Std. Dev. filter (1.5 - typical)". The documentation is a shade vague, but I believe this discards everything more than 1.5 s.d. above & below the mean, then averages. In my first processing attempts I used straight "Average/Default", which would be mean. Perhaps it's partly because I got better, rather than just the difference in the filter, but this looks quite a bit less noisy than my earlier efforts. Min suggests I try 50th %ile, just using the median. Turns out the software supports that. Hmm, I should give it a shot.

Here's a view of one of the raw images, zoomed in around the Horsehead and Flame.

Look at the tool on the right, and you'll see I've set the display to rescale color in the range 2500-2800. This is after demosaicing (turning the raw black & white pixel values into a color image), but with no other processing done on it. If you look closely at the histogram,  you'll see three peaks, which (left to right) are green, blue and red. The current scaling basically hides all of the blue and green. The reds on this camera accumulate counts much faster than either blue or green, which I've spent a LOT of time investigating. When I first saw these, I assumed it was skyglow from city lights, but the same thing is true for my dark frames, so it's the sensor. I don't know if there is some camera setting I should be adjusting, or if I should be tweaking the raw import function. Nebulosity supports a modest number of Canon models, but doesn't have a direct entry for the EOS 7D. I tried them all, some were different, none were better. (As an aside, I would find a better histogram tool, that showed three separate curves, useful; most imaging programs, like GIMP and Photoshop, have that as a default. I think the author of this software does a lot of his work one channel at a time, before combining colors and doing finishing work in another tool.)

Below the bright star you can see the Flame Nebula, standing out above the noise. In the center of the image, you can maybe, maybe, see a dark spot emerging? That's the Horsehead.

Here's the exact same region of the image, after stacking 47 exposures and using 13 dark frames to reduce the floor.  (Note the differences in the histogram and in the B & W sliders. The values are different both because of the dark removal and averaging, and because the above one was 14-bit Canon raw, and this is 16-bit FITS.) Now we have a view!

Next we do a power stretch, to bring up the details on the bottom end of the intensity scale. (n.b.: this is also necessary to keep the Orion Nebula, M42, in a reasonable range; clamping the values like the image you see above turns M42 totally white. M42 is to the right and above, out of frame in this zoomed view, but is important to the final image.)

And now we're pretty much there! I did one final tweak in GIMP to raise the middle of the dynamic range while keeping the top and bottom the same, which gave the image you saw yesterday.

Here's a close-in zoom of the Horsehead, after all the processing. (Click on it to open up and look closer.) This is the number of pixels I've got there, and you can still see some noise. You can also see how good my alignment and mount are, as well as limits of the optics and seeing, by looking at the stars. The really oblong one at the horse's neck is probably an unresolved double star, which you can tell by comparing it to the surrounding stars. The others show drift toward the lower right of about two pixels, which I calculated elsewhere is about the amount of movement in one thirty-second frame.

All of this took me about twenty hours of learning and fiddling and watching YouTube and reading docs, though it sounds simple once I summarize it like this. There are a lot of tutorials on the web on astro image processing, but figuring out which ones to watch is a chore in itself!

Min asked if I'm doing anything about cosmic rays. Not particularly. The dark frames handle "stuck" (or "hot") pixels as well as the current that accumulates even when no light is coming in. With only 47 light frames and set at ISO 1600, you can see that there is a ton of pure noise; I think most of that is thermal/shot noise rather than cosmic rays. A lot of serious amateur astrophotographers have adopted cooled CCD cameras, that work at -10C to -30C. I'd like to have one, but they seem to be expensive, and no doubt are a learning curve in their own right.

To return to the "red accumulates faster" thing, here's M42 from one of the raw images without any adjustment.

Oh, and the final interesting thing from the shoot itself: a train of high-altitude, very dark satellites flew smack through the middle of M42 while I was shooting! Here's a view from the same raw image above.

There are about five of them, moving very slowly and obviously very dark. It took them about 3-4 minutes to cross the area of my frame, about 5 degrees. That's the amount of time it would take an LEO satellite or the ISS to cross the entire sky. They must be thousands of km up. I kept the frames they cross in my total stack, but their trails are tossed out by the stacking algorithm.

Hope you enjoyed this tour through my brain, and my last couple of weeks. See you in the stars, or at least online. Stay safe!

The Importance of Polar Alignment

 One of the major innovations in amateur astronomy since I was a kid is the regular use of polar alignment scopes. They existed, but were beyond my budget and patience as a fifteen-year-old. Now they are standard features on a lot of mounts, including my Kenko Sky Memo S.

So, how good does your polar alignment have to be for astrophotography?

Let's say you're off by one degree, toward R.A. 0, for simplicity. That means that if you're aiming at something at the equator (where the effect will be the worst), your aim will be a degree low at R.A. 0 and a degree high at R.A. 12h. The maximum slew rate will be when you're looking at R.A. 6h or 18h.

How fast is that slew rate? Let's see...that up and down cycle will be two pi per 24 hours...max slope of a sine wave is 1, but gotta match those units...one radian per 3.82 hours...so that would be a max rate of one degree per 3.82 hours. That's 15.7 arcminutes or 942 arcseconds per hour. About one arcsecond of drift every four seconds.

Is that a lot? Well, my professional astronomer friends tell me the seeing at sea level is about 1 arcsecond, at best. It's also about the diffraction limit for a 100mm objective, roughly. So worst case, this would limit our exposure time to four seconds, if our alignment is off by a full degree.

But whether we are working near that limit depends on focal length and camera resolution, too. My Orion photo I just posted was about 3k*5k pixels in the original, covering about 5x7 degrees (before I cropped), shot at 145mm f.l.  I calculated that one pixel in that image is about 6 arcseconds.  (All of this is very back-of-the-envelope, so call it 4 to 8 if you're picky.) So, a 1 degree misalignment would drift by 1 pixel in 24 seconds (well, 20-30, give or take). Since I was stacking 30-second exposures, I only needed to be within one degree!

Very roughly, eyeballing my raw images, over about 25 minutes I drifted by about 90 pixels, about two pixels per shot. A little more than I'd like, but with the stacking I did, not noticeable. In fact, zoomed all the way in, the best stars don't really show any distortion in that direction.

So, I thought I had the polar alignment really nailed during that shooting session, but I might have been off by a full degree. (As it happens, I had to allow rotation as well as translation in the alignment of my stack, which may be due to polar misalignment.)

So I'm in pretty good shape for 30sec exposures with the Canon 70-200mm zoom lens. But if I'm going to shoot long exposures with the new C90 Mak, f.l. 1250 and f/14, I'm going to have to do a lot better than one degree. (I'm also going to need a lower-vibration mount.)

Of course, serious astrophotographers shooting at long focal lengths usually guide their scopes, for exactly this reason, using a longer-f.l. scope and a lighted reticle eyepiece to keep the imaging rig pointed right. It's pretty arduous work. But technology is making this one easier, too, if you've got the budget!

Orion: M42, M43, Horsehead and Flame Nebulae

This is the same data I've been working with for a few weeks now. The two bright stars on the left are two-thirds of Orion's belt, and the bright nebula on the right is the main part of his sword hanging down.  (The image is rotated 90 degrees from what we usually think of as "up" with Orion.) Specs:

• Camera: EOS 7D
• Lens: Canon EF 70-200mm f/2.8
• focal length: 145mm
• f/2.8
• ISO 1600
• Mount: Kenko SkyMemo S equatorial tracker
• Exposure:
• lights: 47 frames, 30 seconds each
• darks: 13 frames, 30 seconds each
• flats: 10 frames using above setup, but I don't really trust them
• bias: none (should I? given how much noise is the problem here...)
• First aligned with rotation (two-star alignment), then stacked using std. dev. 1.5 filter, throwing out extreme points
• Field of view: approx. 5x3 degrees as cropped
• Image size: 3338x2225 as cropped
• Resolution: very roughly, 6 arcseconds per pixel, smallest stars are about 4x4 pixels, so 25-30 arcseconds resolution, I guess, but the brighter stars are about 20x20 pixels
• Faintest stars in the image: good question! I wish I knew.
• Software: Nebulosity 4.4.3, GIMP 2.10
• Date/time: 2020/11/22, about 2:00 a.m. local time
• Location: Arakine Dam, Chiba, Japan

I have learned a ton about CCDs and image processing, but I have probably learned more about this specific camera/sensor and this specific piece of software than about the principles. Because I had so much learning to do, this photo is probably about 20 hours worth of sitting in front of the computer working.

I'm also sitting on 100 frames at 10 seconds, which might add some detail in the middle of M42. I don't know if it's possible to combine them effectively with this or not. I would still like to make the Horsehead more vibrant, but M42 is so bright, that everything I've done to try to brighten the Horsehead turns M42 into just a wash of white. More to learn, yet, but I think this is pretty close to all that this data has to give.

I'm having fun...

C90 Mak: Saturn

 Best shot I got out of a couple of dozen.

Prime focus, 90mm objective, 1250mm f.l., f/14, ISO 800, 1/10th of sec. C90 Mak lens, EOS 7D camera.

Kenko SkyMemo S equatorial tracking drive & accompanying wedge and tripod, roughly hand-aligned using a level and compass (no line of sight to Polaris, and set up before dark, anyway). Vibration is a big problem at this f.l. Most of my shots, even with a 1/10th second exposure, were smeared.

C90 Mak First Light: the Moon!

 

From my first session with my brand-new Celestron C90 Mak. f.l. 1250mm, f/14, so it's not bright. And yet, with my EOS 7D set at ISO 800, this is 1/400th of a second, and even half that might have produced good results.

It was also cloudy; this was snapped between the clouds, and actually with a little haze still present. Kenko Sky Memo S equatorial mount and clock drive, with alignment only guessed at using a compass, and yet the tracking worked reasonably well -- about as well as I ever used to manage with my old Edmund Scientific reflector, but not nearly as good as I managed last week using the polar scope.

If I'm doing the math right, a 90mm objective observing 600nm (orange) light has a diffraction limit of 8 microradians, or 1.65 arc-seconds. The moon here is about 2700 pixels across, smallest features are 5 pixels or less, call it 1/500th of the moon's diameter. 1/500th of 1800 arc-seconds is about 3.6 arc-seconds, so I might actually be close to the maximum theoretical resolution? Off by less than a factor of two would be pretty good. At first glance, I didn't think this scope was anywhere near that good. There does seem to be some scattering I can see in some of my test images, which definitely adds noise/reduces contrast.

Definitely still a lot of learning to do to get the best out of this new tool, but not a bad first effort.

Beginner's Guide to Working with Nebulosity 4

 

I've been getting back into both photography and astronomy, so, astrophotography. The picture above is the Orion Nebula, shot on Nov. 22, 2020, and processed with Nebulosity 4 software as well as Gimp. It represents my best effort so far, in optics (improved focus and exposure), mechanics (polar alignment, tracking and vibration), and image processing. I think the raw data I took that night still has more to give, so I'll keep working on it. Click on the image for an expanded view!

Nebulosity 4 is astrophoto software that can control some digital cameras and provides a great many editing features for the resulting images. I acquired it because I liked its image stacking features the best of three or four tools I tried on the Mac, but I'm gradually using more of the features. I don't have any real plans to shift to full laptop/software control in the field right now, but you never know.

It turns out that, despite the more-expensive-than-a-game-but-ridiculously-low-for-professionals price of US$95, documentation is a little sparse, so it has taken me a while to kind of grasp the expected workflow, including learning about darks and flats and biases. Most frustratingly, after learning about those concepts, I spent quite a while trying to understand the basic mechanics of working with Canon CR2 raw image files. So, I'm collecting what I've learned so far, in this blog post.

Resources:

• Really, the first thing to look at is the Nebulosity 3 manual, since there is (AFAICT, as of 2020/11/26) no separate Nebulosity 4 manual yet. (Frustratingly, I kept the link directly to that PDF, but not the page that linked to it, and now I can't find the web page -- an indication that the website needs some love? Ah, found it again -- it's under "Downloads", but you have to scroll down.) In that document, on p. 29, you'll find a nine-step formula for processing images -- exactly what I was looking for, and which took me hours to find. It's the basis for what I write below.
• This YouTube video by Alex Cardenas is fantastic. It's a near-perfect tutorial on how to do the stacking in Nebulosity, once you have your set of frames ready. However, Alex was working from separate sets of R, G, and B files, whereas I'm working first from JPEGs and then from Canon raw files.
  
• This info on Canon CR2 raw image files was a big help in learning about what's going on in the raw files themselves, and what needs to happen to turn them into color images. In particular, Section 4 of that shows how pixels are laid out on the sensor chip, which helps you understand what you're seeing if you are looking at the whole raw file in black and white. Armed with this info, I was able to figure out what operations needed to happen, then the next step was to learn how to make them happen in Nebulosity (see the first bullet point in this list).
  
• This presentation by Craig Stark from 2014 is good enough to be useful, but it's long, almost two hours. The best part I've seen so far (I'm about halfway through) starts at 22:10, discussing the basic linear math of what he calls "Classic dark subtraction". I'm sure there are other good sources on the particular topic on the web.

I'll put more about my process into another post.

The image at the top:

Orion Nebulae M42, M43, in the sword hanging down from Orion's belt. The image is turned sideways; the two bright stars to the left are two-thirds of the belt.  Around the lower one (left as we usually think of it), Alnitak (zeta Orionis), there is visible also a bit of nebula.

• Camera: EOS 7D body, APS-C sensor
• Lens: Canon EF70-200 f/2.8L USM lens, set at 145mm f.l.
• Settings: ISO 3200, f/2.8, 30 second exposures
• Mount: Kenko SkyMemo S equatorial drive and leveled tripod
• Images: high-quality JPEG
• 47 light frames
• 15 dark frames (camera is old, with a lot of stuck pixels, so the darks really help!)

The focus may not have been perfect, but was pretty good; achieved using simulated exposure and digital zoom to set focus, and at max zoom could see quite a bit of vibration from the mount.

I'd like to reshoot with zoom set at 200mm, and possibly stopped down to see if that reduces some of the coma, but fundamentally I think this is pretty close to the capability of this lens, sensor and mount.  Raw images are also pretty noisy, should try ISO 1600 or even 800.

Shot around 3am local time, about 3.5 hours before sunrise.  Shot at Arakine Dam, Chiba Prefecture; perhaps the best dark within two hours' drive of our house, but you can still see quite a bit of sky glow from Chiba city and Tokyo.  The Himalayas it ain't.

Stacking done with Nebulosity, which seems to be excellent for this task.  A little more flexibility in adjusting the light curves would be nice, but that's easy in Gimp once the alignment and stacking are done.  For this image, I simply set a black level floor of around the sky glow, no other light curve tweaking; cropped in Gimp.

The Organizations I Work With, Or, Where my Time Goes

 If you're waiting on an answer to an email from me, or I owe you a document, or for some reason my inability to get something done is inconveniencing you, I apologize.  I really shouldn't spread myself so thin, but the fact is that there are a lot of things in this world I care about. Worse, as a professor, I don't have a boss. The great thing about not having a boss is that nobody tells you what to do. The terrible thing is that nobody tells you what not to do.  There's no one to defend you: "That's a great project, but Rod's busy. He's available the middle of next year, or you can find some else."

As a prof, we have essentially four major duties:

• Teaching: one of the big, obvious ones.
• Research: the other big, obvious one. This includes both doing the research yourself, and managing the research (budgets, schedules, purchasing, hiring, etc.).
• University service (running the university): the amount of this varies depending on your position, how useful you are (making yourself useless/unreliable gets you out of some of this), and the structure of your institution.
• Community service: participating in your community, defined however is appropriate for you. Might be the literal community around your campus, might be running a journal or a conference.

For me, and for most of us, community service means working with colleagues in our own and other universities, companies, government labs, and government committees,  to further the field as a whole. In some cases, this benefits your own research projects, in some cases it's much more indirect.

My primary research area, as you probably know, is quantum computing and quantum networking, but I also care about computer networking in general, and distance education and educational technology (though I have no formal training in the latter).

So, here are most of the organizations I'm working with these days (as of 2020/10/1). Some of these are internal to Keio, i.e. a structure for doing research.  Others are external.

• AQUA: my own quantum computing & quantum networking research group at Keio's Shonan Fujisawa Campus. Truly, the center of my professional life.
• RG: our larger lab on campus, an umbrella for managing over 100 undergrads in a broad variety of computing areas.
• AQUA @WIDE: there is also the AQUA working group inside of the WIDE Project. We generally hold a small meeting during the semi-annual WIDE Camp, or run a tutorial during the semi-annual WIDE Kenkyuukai, things like that.
• WIDE: I'm a WIDE Project Board Member. I do much less for WIDE than most of the other board members, but even so I do quite a bit.
• KQCC: the Keio Quantum Computing Center, where I am Vice Center Chair. I supervise and participate in a good fraction of the research, but the Founder and Center Chair have actually done most of the heavy lifting on paperwork, recruiting member companies and partners, hiring, etc.
• CCRC: the Keio Cyber Civilization Research Center. Rather than a driver, I'm a participant here, but this is important work, as well.
• SOI-Asia and AIII: my involvement here is small, but I do what I can. We're working with some of the SOI-Asia partners to share our MOOC on quantum computing, including translating the MOOC into important languages in Southeast Asia. I also have one Ph.D. student working on technology in language teaching, and this is one of her primary "homes".
• AINTEC: I'm on the steering committee for the Asian Internet Engineering Conference.
• JFLI: I'm Keio's representative to the Japan-France Laboratory for Informatics.
• QIRG: I'm co-chair of the Quantum Internet Research Group, part of the Internet Research Task Force (IRTF).
• IRSG: being co-chair of QIRG puts me on the Internet Research Steering Group. This means I should be doing a lot more for the IRTF as a whole than I have been.
• QITF: here in Japan, we are standing up the Quantum Internet Task Force, bringing together most of the researchers in Japan who are working on quantum repeaters.
• WQRN: I'm part of the organizing committee for the Workshop for Quantum Repeaters and Networks.
• TQE: I've joined the editorial board of IEEE Transactions on Quantum Engineering, for the moment as an editor for the special section but probably more work coming up.

This doesn't even list the campus committees and program (department) duties, etc. It also doesn't even begin to address handling my research projects -- all that's just lumped under "AQUA" up there at the top.

And in a normal year, I travel to visit collaborators in Thailand, Paris, U.S., Hyderabad, etc., not to mention the conferences and meetings. I often feel depressed and overwhelmed by work, like I'm not getting anywhere near enough done. But then I look at this list, and wonder how I ever get any sleep and time at home.

[Edit on 20/12/3: Add JFLI]

5.1 Shor 'Nuff

(See the top of this set of postings.)

Obviously, the main thing we're talking about here is Shor's algorithm.  I have not been privy to the conversations of cryptographers in creating post-quantum crypto, though we'll take a short look at that below.  But there are very few people in the world who understand better than I do what it takes to actually run the full version of Shor's algorithm on a potentially real machine.

A full implementation of Shor's algorithm consists of two quantum phases: modular exponentiation, followed by the quantum Fourier transform.  (I'm assuming you're familiar with the main ideas behind Shor, how it uses interference to build patterns in the quantum register that can reveal the period of a function that allows us to find the factors of a large semi-prime number.)

The key insight may be the behavior of the QFT, but the bulk of the execution time will be in the modular exponentiation phase.  This is actually one of the areas that I worked on in my Ph.D. thesis.

https://arxiv.org/abs/quant-ph/0607065

Some of the important parts of this were published in Physical Review A.

In my thesis there is a plot that I think is useful, which we updated and published in our Communications of the ACM article:

https://m-cacm.acm.org/magazines/2013/10/168172-a-blueprint-for-building-a-quantum-computer/fulltext

We worked out detailed performance estimates, including hardware requirements and quantum error correction, in some of our papers:

https://journals.aps.org/prx/abstract/10.1103/PhysRevX.2.031007

and

https://www.worldscientific.com/doi/abs/10.1142/S0219749910006435

https://arxiv.org/abs/0906.2686

There were other, contemporary important papers on how to implement Shor, including Fowler et al.,  https://arxiv.org/abs/quant-ph/0402196 who discussed Shor on a linear array, a few months ahead of my own Phys. Rev. A paper on the same topic.

We both built on important, early work by Vedral, Barenco and Ekert (VBE) and by Beckman, Chari, Devabhaktuni and Preskill (BCDP).

https://arxiv.org/abs/quant-ph/9511018

https://journals.aps.org/pra/abstract/10.1103/PhysRevA.54.147

https://arxiv.org/abs/quant-ph/9602016

https://journals.aps.org/pra/abstract/10.1103/PhysRevA.54.1034

If you are looking to broaden your reading on implementations of Shor’s algorithm, the following are useful:

Pavlidis and Gizopoulous found an efficient division algorithm, accelerating the math.

https://arxiv.org/abs/1207.0511

https://dl.acm.org/citation.cfm?id=2638682.2638690

Roetteler, Steinwandt focused on the applicability of Shor's algorithm to elliptic curve. I like the paper, except I think their survey of related research could have been better.

https://arxiv.org/abs/1306.1161

and Roetteler, Naehrig, Svore, Lauter:

https://arxiv.org/abs/1706.06752

Gidney and Ekera submitted to the arXiv a paper on factoring a 2048-bit number using 20 million noisy quibits.  In this paper, one of their techniques is arithmetic "windowing" which is essentially identical to one of the techniques I proposed in my 2005 Phys. Rev. A paper.  https://arxiv.org/abs/1905.09749

May and Schliper also recently uploaded a paper on period finding with a single qubit.

https://arxiv.org/abs/1905.10074

Ekeraa and Hastad also proposed a new period-finding algorithm variant, in 2017.

https://link.springer.com/chapter/10.1007/978-3-319-59879-6_20

https://arxiv.org/abs/1702.00249

Smolin, Smith, Vargo wrote something of a warning about inferring too much from very simple demonstrations on a few qubits.

https://www.nature.com/articles/nature12290

Here is one early paper on how to assess errors in Shor’s algorithm, by Miquel, Paz and Perazzo:

https://arxiv.org/abs/quant-ph/9601021

https://journals.aps.org/pra/abstract/10.1103/PhysRevA.54.2605

Chuang et al., also published an early examination of decoherence in factoring.

https://science.sciencemag.org/content/270/5242/1633

Among random things, there is Dridi and Alghassi, factoring on D-Wave; I don’t think this paper tells us very much about factoring at scale.

https://www.nature.com/articles/srep43048

That's more than enough for now, since it isn't really the focus of what we're after here, anyway.

5. Attacking classical cryptography using quantum computers

Naturally, my own interest in writing these notes stems from my experience in quantum computing and quantum networking.  The previous sections dealt primarily with classical attacks, with a little bit of quantum networking can be integrated with classical thrown into each section.  Here, let's look at the attacks on classical cryptography using quantum computers.

4.5 Notes & References

To be filled in eventually.

4.4 TLS and QKD

Alan Mink, Sheila Frankel and Ray Perlner worked on integrating TLS with QKD, a full decade ago.

https://arxiv.org/abs/1004.0605

4.3 Other Attacks on TLS

One startling and potentially useful document is RFC7457, "Summarizing Known Attacks on Transport Layer Security (TLS) and Datagram TLS (DTLS)".  It details a couple of dozen attacks on TLS, most having to do with protocol implementation issues such as failing to correctly verify all of the information you are given.  Some of them leak information or allow a connection to be take over, others allow an attacker to downgrade the security negotiation so that a later attack on the cipher has a higher chance of success.

One attack this RFC points out is http://www.openssl./~bodo/tls-cbc.txt, which (among other things) describes a flaw in how TLS Record Protocol records are concatenated. Originally, TLS kept the ciphertext of the last block of a record to use as the initialization vector (IV) of the first block of a new record, but this allows an attacker who can adaptively choose plaintexts to more completely choose the text being encrypted.  The fix is straightforward (toss in an extra block of nonsense data before starting the new record), and current versions of TLS aren't vulnerable.

4.2 Keying and Rekeying

(To be filled in.)

<>

<sure that an attacker can't cause a downgrade of security relative to
what both ends really want.>>

<>

4.1 TLS Records and Basic Limits

TLS consists of one primary protocol: the TLS Record Protocol.  On top of the TLS Record Protocol sit four protocols, one of which (the application data protocol) is used for the bulk data encryption, and the TLS Handshake Protocol, which utilizes public key cryptography to establish identity, securely creates a shared secret to be used for the bulk data encryption, and makes sure that this part of the process can't be modified by an attacker.  A third one of interest to us is the change cipher spec protocol.

A record in the record layer has a maximum size of 16KB ($2^{14}$).

There is, as best I can tell, no official limit on the key lifetime or on the number of bytes that can be pushed through a single TLS except the limit on record sequence numbers of $2^{64}-1$.  Combined with the max record size, that's $2^{78}$ bytes, or 256 exabytes, which is a bloody lot of data.  So, if the lifetime of a session needs to be limited, it has to be done by breaking the connection and renegotiating. Apparently, adding a key renegotiate feature was considered for TLS 1.3, but doesn't seem to have been included.

Luykx and Paterson wrote up a short (8 page) summary recommending limits for TLS with different cryptosystems. (My copy is dated Aug. 2017, but the paper was referred to in Apr. 2016.) http://www.isg.rhul.ac.uk/~kp/TLS-AEbounds.pdf
Unfortunately, that paper has good references but doesn't go through the complete reasoning, so going one level deeper in the reading is really necessary.

In April 2016, Mozilla moved to limit the length of a connection, based on those results:
https://bugzilla.mozilla.org/show_bug.cgi?id=1268745
They set AES-CBC to about $2^{34.5}$, or about 24 billion records, about 400 terabytes max.  That should give a probability of $2^{-57}$ of "ciphertext integrity [being] breached", though I'm a little unclear on exactly what that means here -- is this just birthday bound leaking some plaintext, or is this compromise of the entire session key? Figuring that out will take more digging, since they express things differently than most of the resources I used above.

4. TLS/SSL and cryptography

(Back to the top of this sequence of postings.)

Here we want to answer the same three questions we had above about IPSec:

1. What are the technical mechanisms in place for rekeying and effective use of encryption?
2. What was known, at the time these protocols were developed, about the best practices for rekeying?
3. What are best practices today?

but this section will be much shorter, as I know so much less about TLS (despite the fact that it is the most important use of encryption on the Internet today).

The current standard for Transport Layer Security, or TLS, is RFC8446, published in 2018.  It specifies version 1.3 of the protocol.  The main document itself is only 160 pages, not bad for something so complex and important.

...oh, what is TLS?  It's the protocol that HTTPS runs over.  It's the successor to SSL, the Secure Sockets Layer, which was the first way to encrypt web browsing.  TLS originally built on top of a reliable transport protocol, such as TCP, though a later adaptation (RFC6347) lets it run over a datagram protocol.  We'll only worry about running it over TCP here.  TLS provides privacy, by encrypting all of your web browsing traffic for a particular connection.  It also provides data integrity, using a MAC (message authentication code) when necessary. (IPsec also does both, but we ignored that above.)

3.5 Notes & References

To be filled in eventually.