IonQ's Quantum Breakthrough: Shor's Algorithm Advancements

I am pleased to announce the publication of my first arXiv preprint: "Accelerating Quantum State Encoding with SIMD: Design, Implementation, and Benchmarking." Efficient data encoding has long been a bottleneck in hybrid quantum-classical algorithms, with traditional simulators spending significant time converting classical features into quantum rotations. To address this, our team developed the Hybriqu Encoder, a Rust-based, SIMD-aware kernel that focuses exclusively on angle encoding and integrates seamlessly with Python via CFFI. By processing multiple double-precision rotations simultaneously using AVX-class vector lanes, utilizing pre-calculated trigonometric factors, and optimizing for cache performance, we achieved a 5.4% speedup at 64 qubits on Apple Silicon. This performance scales effectively as data exceeds the L1 cache size, demonstrating that vectorization provides consistent improvements for compute-bound encoding tasks. Our benchmarking also identified that kernels applying rotations to the entire state vector remain heavily limited by memory bandwidth rather than compute power. This highlights a clear path for future optimization regarding state updates and processing methods in larger hybrid quantum-classical systems. A huge thank you to my co-authors Irwan Alnarus Kautsar, Gunawan Witjaksono, and Haza Nuzly Bin Abdull Hamed for their collaboration and support on this work. You can read the full preprint here: https://lnkd.in/gKMNt57B #QuantumComputing #MachineLearning #RustLang #HighPerformanceComputing #SIMD #QuantumSimulation #ArXiv

🤫 🤫 😁 I have placed a hardened, un-hackable translation layer between the raw neural network and the physical operating system. But that's not even the "big deal", sometimes you have to go back to go forward and going forward is just so you can go back. It's quantum stuff, loopy eh? 😜 This is the exact moment when the entire project—months of theoretical physics, quantum mapping, compiler design, and micro-kernel architecture—collapses into a single, elegant, terrifyingly powerful point of focus. More on that later....

Quantum error correction shouldn’t be manual. But today, it is. Most quantum stacks like Qiskit and Q# push error correction into libraries, forcing developers to hand-build syndrome circuits with no compile-time guarantees. So I built something different: QSHL (Quantum Self-Healing Language) A programming language where error correction is built in—not bolted on. What’s different: → Heal Blocks Define error correction once. The compiler generates the full syndrome + correction loop automatically. → Linear Qubit Ownership Prevents use-after-measurement and invalid quantum states at compile time. → Coherence-Aware Compilation If your program exceeds the hardware’s coherence window, it fails before it runs. → Rust-native pipeline No Python overhead. Low-latency classical control for real-time decoding. Results: In simulation, QSHL achieved a 55.6% error “heal rate” at a 5% gate error, completing correction cycles within the coherence window using a Sparse Blossom decoder. We’ve filed a provisional patent on the architecture at Korelis Labs. I’m currently exploring QIR / OpenQASM 3.0 integrations and early pilot opportunities with teams working on real quantum systems. If you’re in the quantum space—let’s talk. #QuantumComputing #QEC #RustLang #DeepTech #KorelisLabs

🎉 Milestone: true-qrandom hit 100+ downloads in its first month on PyPI! I built true-qrandom — a Python package that generates genuinely random numbers using real IBM Quantum hardware via Qiskit Runtime. Classical computers can only produce pseudo-random numbers — deterministic sequences that merely appear random. true-qrandom works differently: ⚛️ How it works: Each qubit starts in ground state |0⟩ → a Hadamard gate puts it in 50/50 superposition (|0⟩ + |1⟩)/√2 → measuring collapses it to 0 or 1, governed purely by quantum mechanics — not an algorithm. 🔬 Where you can use it: • QKD protocols (BB84) — true randomness is a hard requirement for secure quantum key generation • Cryptographic key & token generation — provable entropy, not pseudo-randomness • Quantum circuit benchmarking & research • Any application where deterministic randomness is a security risk 🛠️ Features: • Familiar random module API — same interface, quantum backend • Multiple output types — integers, floats, bytes, raw bits • Local simulator mode for development (no credentials needed) • Efficient single multi-qubit circuit per request 📦 Install: pip install true-qrandom 🔗 GitHub: https://lnkd.in/eRdCiwDd Feedback, issues, and contributions are very welcome! #QuantumComputing #Python #OpenSource #Qiskit #IBMQuantum #QKD #Cryptography #QRNG

I’ve started running a set of experiments with quantum computing applied to iGaming systems. Two parallel tracks. First: probabilistic modeling. Building a toy framework to estimate RTP and rare event probabilities using quantum techniques, then benchmarking it against classical Monte Carlo. My objective is to understand whether methods like amplitude estimation change anything in practice when it comes to expected value, variance, and edge-case modeling. Second: RNG architecture. Exploring a hybrid model where quantum-generated entropy feeds into a standard deterministic RNG pipeline. My focus is on entropy quality, conditioning, statistical validation, and whether this can integrate into systems that require auditability and certification. Stack is Python with Qiskit, starting on simulators and then pushing runs to real quantum hardware. This has nothing to do with predicting outcomes or reinventing gambling math. If there’s something real here, it will show up in measurable differences. I’ll share results once I have data worth looking at.

As a PhD student, I often find it challenging to explain foundational quantum concepts simply. Thus, I’ve decided to start a series sharing hands-on implementations of quantum computing! My goal is to share my knowledge and help fellow quantum enthusiasts learn these concepts through practical code. In this first video, I break down the Bell State (quantum entanglement). I start with a simple "Magic Coin" visual analogy, and then walk through the actual circuit implementation using Qiskit. You can find the Python code on my GitHub repo here: https://lnkd.in/g3wYiJx7 For the visual circuit implementation, I utilized the IBM Quantum Composer: https://lnkd.in/g7TPjiqz Thanks to Qiskit library from IBM and for the animations Google's Gemini have been used. #QuantumComputing #Qiskit #PhDLife #IBMQuantum

Quantum computers don’t run code. They run circuits. That’s the first mental shift you need to make. In classical computing, we write programs step by step instructions executed sequentially in languages like Python or C++. Quantum computing works differently. Instead of code, you design a quantum circuit a sequence of quantum gates applied to qubits. Each gate doesn’t “compute” in the classical sense. It transforms the state of a qubit shaping probabilities, not flipping bits. You’re not telling the computer what to do step by step. You’re constructing a system that evolves according to quantum mechanics. And at the end of the circuit? You measure. That’s when probabilities collapse into an actual result. This is why quantum programming feels less like coding… and more like designing an experiment. From instructions → to transformations From logic → to physics This is Day 2 of understanding how quantum computers actually compute. Next: What exactly is a quantum gate? #QuantumComputing #QuantumAlgorithms #QuantumCircuits #DeepTech #FutureOfComputing #EmergingTech #day2 #computation

𝗤𝘂𝗮𝗻𝘁𝘂𝗺 𝗖𝗼𝗺𝗽𝘂𝘁𝗶𝗻𝗴 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲: 𝟭. 𝗧𝗵𝗲 𝗖𝗹𝗮𝘀𝘀𝗶𝗰𝗮𝗹 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗟𝗮𝘆𝗲𝗿 (𝗧𝗵𝗲 𝗕𝗿𝗮𝗶𝗻) Everything starts with code. Using Python and Qiskit, algorithms are translated by compilers into low-level instructions. These are then converted into precise microwave pulses that act as the "remote control" for our qubits. 𝟮. 𝗧𝗵𝗲 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 & 𝗥𝗲𝗮𝗱𝗼𝘂𝘁 𝗟𝗶𝗻𝗲𝘀 (𝗧𝗵𝗲 𝗡𝗲𝗿𝘃𝗼𝘂𝘀 𝗦𝘆𝘀𝘁𝗲𝗺) These lines travel down the "Chandelier." They are equipped with attenuators and filters to strip away thermal noise. In the quantum world, heat is the enemy; even a tiny amount can cause decoherence and destroy the calculation. 𝟯. 𝗧𝗵𝗲 𝗖𝗿𝘆𝗼𝗴𝗲𝗻𝗶𝗰 𝗨𝗻𝗶𝘁 & 𝗤𝗣𝗨 (𝗧𝗵𝗲 𝗛𝗲𝗮𝗿𝘁) At the bottom of the Dilution Refrigerator lies the Quantum Processor Unit (QPU). 𝗧𝗵𝗲 𝗖𝗵𝗮𝗻𝗱𝗲𝗹𝗶𝗲𝗿: Cools the system to 15 Millikelvin (colder than outer space!). 𝗝𝗼𝘀𝗲𝗽𝗵𝘀𝗼𝗻 𝗝𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗤𝘂𝗯𝗶𝘁𝘀: Superconducting circuits that perform the heavy lifting. 𝗥𝗲𝘀𝗼𝗻𝗮𝘁𝗼𝗿 𝗥𝗲𝗮𝗱𝗼𝘂𝘁: The mechanism that captures the final result and sends it back to our classical world. This dynamic interaction between classical software and superconducting hardware is the foundation of the next computational revolution. 𝗔𝗿𝗲 𝘄𝗲 𝗿𝗲𝗮𝗱𝘆 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗤𝘂𝗮𝗻𝘁𝘂𝗺 𝗘𝗿𝗮? 🚀 #QuantumComputing #DeepTech #CyberSecurity #Innovation #FutureOfTech #IBMQuantum #Qiskit

Following our previous work, RSR (ICML'25), we developed RSR-core, a system designed to make low-bit LLM inference significantly more efficient. RSR-core turns the RSR algorithm into optimized CPU and CUDA kernels for fast binary and ternary matrix–vector multiplication, enabling practical acceleration inside real inference pipelines. In particular, it improves the efficiency of ternary LLM inference, achieving substantial speedups over standard PyTorch baselines. We’re actively continuing to build and improve the system, and we’re excited to explore its applications in efficient LLM deployment and low-bit model inference. The video below shows a side-by-side comparison of ternary decoding on CPU using RSR-core vs the PyTorch (bfloat16) baseline on bitnet-b1.58-2B model. If you're interested in efficient LLM inference, quantization, or low-bit model deployment, take a look: 💻 Code: https://lnkd.in/gk5dvJM5 📄 RSR-core preprint: https://lnkd.in/giYyMm_k 📄 RSR original paper (ICML’25): https://lnkd.in/gW_SRpAz Thanks to Abolfazl Asudeh for collaboration on this research direction. #LLM #EfficientInference #Quantization #MachineLearning #CUDA #bitnet

One of our coolset products in last few years, led by Mohsen Dehghankar: RSR-core implementats our RSR algorithm [ICML’25] into highly optimized CPU and CUDA kernels, delivering fast binary and ternary matrix–vector multiplication for real-world inference workloads. It is particularly effective for ternary LLM inference, where it provides significant performance gains compared to standard PyTorch baselines, enabling more efficient deployment in production pipelines.