8Q: The DIY Quantum Computer

I hope you all didn't forget about this project, I certainly haven't! I find I have more and more projects I want to work on and less and less time, but this, and my other quantum projects, are still my favorite ones.

A few updates on what's been happening:

1. Replaced CPU with a CoM board:
   1. Due to it being like pulling teeth trying to get chip specs, I've decided to go a different route for the digital portion utilizing the Congo A50-line of QSeven2.0 Computer on Module's to replace the Allwinner processor.
2. Updated Schematics
3. (Re)Created library and footprint files for quantum parts
   1. This would actually be a good beginner task for anyone interested in helping out, we need to make sure that all the components are utilizing the proper library and not the cached libs so that our project can remain portable.
   2. I'm considering creating a separate git with the actual components to make it easier to import them, but that'll be for a later time.
4. Began Work on PCB layout
   1. YES! We are actually moving towards manufacturing our very own quantum computer!!!!!!
   2. The current target size is a standard 19x28" 1U Server Rack
5. Began Working on Miniaturizing Components
   1. We are currently evaluating various methods of reducing the component scale and consolidating larger packages.

Progress is definitely slower than when we first began as we march towards making a manufacturable product rather than just a pretty, theoretical-physics-themed wall-art, but the progress we do make here is also going to further our progress in our other projects- like QEDA and even our non-quantum offerings.

Hey guys, sorry for the delay in updates, my development computer was running way too slow to get any meaningful work done (can you believe I designed this on a jailbroken chromebook with a modified linux kernel?), so this past week I've been building and configuring a beastly development computer (been fiddling to undervolt and OC the GPU and CPU, running benchmarks, etc.)

Right now I'm setting up a new development environment, transferring files over from my old drive, etc. I'll be writing up a shell script for linux to create the development environment so if anyone wants to contribute they don't have to try and do it manually.

I'm also starting a livestream at twitch.tv/SpookyMFG, it won't be all focused on this project, just a sort of general vlog of what I'm working on if anyone's interested.

I've been working on this project in private for a fairly long time, there is quite a bit of work to be done especially on the documentation side as well as with making the components readily available, I think the best option is to start by re-formatting the existing documentation and theory of operation for the 8Q core processor, from there I need to create a new library for the logic gates and control circuitry in KiCAD.

Making the computer linux ready I don't foresee taking incredibly long as I've made the decision to isolate the quantum circuitry entirely from the digital circuitry and communicate over some form of digital bus.

I'm still debating whether to use the SPI to communicate with the quantum processing unit or if I should use the (much) faster (and much more complex) PCIe ports available on the H6.

Going with the PCIe side of things, as the design improves and the materials used shrink down (currently the QPU is going to be the size of a small table!), it would be advantageous to have PCIe capabilities from the start, you'd be able to upgrade any existing PC with the QPU without making any major hardware changes. As far as performance and the like goes, there isn't really any major advantage to be achieved as we're expecting these to start off painfully slow.

The ISA for the QPU is pretty much defined by the hardware and is a hard constraint, but if we want it to be compatible with existing quantum programming languages like e.g. OpenQASM, we need to do a little bit more to reduce the number of instructions required for the end user. This may also be a hard requirement due to the significant speed differences between the electrical and optical circuits. (Yes, electricity travels close to the speed of light, but not close enough for us to discount it entirely).

Basically you need to send instructions to the QPU in incredibly tight time constraints, and the QPU needs to execute them similarly. This is particularly the case with controlled gates which need to fire ancillary photons so that they arrive simultaneously with the control and target qubits to reduce unwanted phase synchronization problems. To reduce these time constraints from angstroms to something more reasonable with macro-scale hardware, we've introduced delay loops which allow just enough time (on the order of ms) for the QPU control logic to execute a single instruction; we could increase the delay loops to allow for more instructions, but every increase in latency exponentially increases the error rate (which is bad). There's far too much to get into with this, but ultimately we need a simplified ISA for our QPU/CPU bridge.

We also really should take the time to create an algorithm to determine success probabilities of a given algorithm to determine the number of times you need to repeat a given operation (and ultimately how long the operation will take), ideally this would be taken care of by the compiler, but given the fact we are working with exponential failure rates I think it would probably be very useful to have the QPU do some verification on its' own and raise a conditional error dependent on a flag so people don't inadvertently send a program that can't successfully be run in less than a reasonable time (e.g. several days).

Finally, we need to write a compiler for our new ISA; I'm looking to target a reduced version of OpenQASM to start as it's the Quantum Assembly Language I'm most familiar with.

Anywho, short summary of work to be done on the 8Q Core:

• Reformat Documentation For Github/ReadTheDocs
• Decide PCIe vs SPI
• Create a Simplified Instruction Set Architecture For QPU/CPU Bridge
• Upload KiCAD Libraries
• Create Pre-Processing Success Probability Algorithms
• Design QPU/CPU Bridge & QPU Controller