#qiskit — Public Fediverse posts

Been learning quantum on the side for months. What tripped me up wasn't the math — it was how often "canonical" circuits from papers and tutorials fail quietly. Broken Hamiltonians. Reversed bit orders. Silent API drift.

So I built a personal library where every circuit is checked against its reference output before it's listed. 50+ curated circuits across Qiskit, PennyLane, and Cirq. No signup required.

→ https://qubithub.co?utm_source=mastodon&utm_medium=social&utm_campaign=m25-library-open&utm_content=personal

#LearningInPublic #QuantumComputing #Qiskit

Been learning quantum on the side for months. What tripped me up wasn't the math — it was how often "canonical" circuits from papers and tutorials fail quietly. Broken Hamiltonians. Reversed bit orders. Silent API drift.

So I built a personal library where every circuit is checked against its reference output before it's listed. 50+ curated circuits across Qiskit, PennyLane, and Cirq. No signup required.

→ https://qubithub.co?utm_source=mastodon&utm_medium=social&utm_campaign=m25-library-open&utm_content=personal

#LearningInPublic #QuantumComputing #Qiskit

Writing my first quantum computing experiments (simulated only for now, using IBM Qiskit). It’s great to be collaborating again with my former undergraduate research advisor and his students... Almost 20 years after graduation. Some light academic work makes me very happy. One day I’ll still go back and finish my Master’s... I've dropped out twice, third time's the charm :)

https://www.ibm.com/quantum/qiskit

#QuantumComputing #Qiskit #Academia #Research #Tech #ContinuousLearning

Updated: I added the aha-chapter that I was missing.

"Quantum computers try all possibilities in parallel" is the popular line — and it's dangerously misleading. A measurement collapses everything to one random answer, so "parallel" on its own is useless.

The actual move: a quantum algorithm is ONE global linear transformation on a 2^n-amplitude vector, designed so wrong answers destructively cancel and the right one amplifies. Classical searches. Quantum shapes.

Walkthrough with a Grover-style bar chart in four snapshots, plus the full pipeline: superconducting oscillator → Josephson junction → Bell state → amplitude amplification → Shor / Grover / simulation.

🔗 https://ki-mathias.de/en/quantum-computing.html
🎥 https://youtu.be/iMaqNfA0Gs0 (9:14, HD)
📦 Qiskit notebooks: https://github.com/pmmathias/quantum-computing

#quantumcomputing #qiskit #qubit #interference #grover #blochsphere #physics #education

Updated: I added the aha-chapter that I was missing.

"Quantum computers try all possibilities in parallel" is the popular line — and it's dangerously misleading. A measurement collapses everything to one random answer, so "parallel" on its own is useless.

The actual move: a quantum algorithm is ONE global linear transformation on a 2^n-amplitude vector, designed so wrong answers destructively cancel and the right one amplifies. Classical searches. Quantum shapes.

Walkthrough with a Grover-style bar chart in four snapshots, plus the full pipeline: superconducting oscillator → Josephson junction → Bell state → amplitude amplification → Shor / Grover / simulation.

🔗 https://ki-mathias.de/en/quantum-computing.html
🎥 https://youtu.be/iMaqNfA0Gs0 (9:14, HD)
📦 Qiskit notebooks: https://github.com/pmmathias/quantum-computing

#quantumcomputing #qiskit #qubit #interference #grover #blochsphere #physics #education

Updated: I added the aha-chapter that I was missing.

"Quantum computers try all possibilities in parallel" is the popular line — and it's dangerously misleading. A measurement collapses everything to one random answer, so "parallel" on its own is useless.

The actual move: a quantum algorithm is ONE global linear transformation on a 2^n-amplitude vector, designed so wrong answers destructively cancel and the right one amplifies. Classical searches. Quantum shapes.

Walkthrough with a Grover-style bar chart in four snapshots, plus the full pipeline: superconducting oscillator → Josephson junction → Bell state → amplitude amplification → Shor / Grover / simulation.

🔗 https://ki-mathias.de/en/quantum-computing.html
🎥 https://youtu.be/iMaqNfA0Gs0 (9:14, HD)
📦 Qiskit notebooks: https://github.com/pmmathias/quantum-computing

#quantumcomputing #qiskit #qubit #interference #grover #blochsphere #physics #education

Updated: I added the aha-chapter that I was missing.

"Quantum computers try all possibilities in parallel" is the popular line — and it's dangerously misleading. A measurement collapses everything to one random answer, so "parallel" on its own is useless.

The actual move: a quantum algorithm is ONE global linear transformation on a 2^n-amplitude vector, designed so wrong answers destructively cancel and the right one amplifies. Classical searches. Quantum shapes.

Walkthrough with a Grover-style bar chart in four snapshots, plus the full pipeline: superconducting oscillator → Josephson junction → Bell state → amplitude amplification → Shor / Grover / simulation.

🔗 https://ki-mathias.de/en/quantum-computing.html
🎥 https://youtu.be/iMaqNfA0Gs0 (9:14, HD)
📦 Qiskit notebooks: https://github.com/pmmathias/quantum-computing

#quantumcomputing #qiskit #qubit #interference #grover #blochsphere #physics #education

Updated: I added the aha-chapter that I was missing.

"Quantum computers try all possibilities in parallel" is the popular line — and it's dangerously misleading. A measurement collapses everything to one random answer, so "parallel" on its own is useless.

The actual move: a quantum algorithm is ONE global linear transformation on a 2^n-amplitude vector, designed so wrong answers destructively cancel and the right one amplifies. Classical searches. Quantum shapes.

Walkthrough with a Grover-style bar chart in four snapshots, plus the full pipeline: superconducting oscillator → Josephson junction → Bell state → amplitude amplification → Shor / Grover / simulation.

🔗 https://ki-mathias.de/en/quantum-computing.html
🎥 https://youtu.be/iMaqNfA0Gs0 (9:14, HD)
📦 Qiskit notebooks: https://github.com/pmmathias/quantum-computing

#quantumcomputing #qiskit #qubit #interference #grover #blochsphere #physics #education

量子×クラウドはなぜ難しい？第4の壁：量子クラウドの待ち行列問題
https://qiita.com/imh1104/items/84dd7d5dee9884a008fa?utm_campaign=popular_items&utm_medium=feed&utm_source=popular_items

#qiita #Cloud #アーキテクチャ #量子コンピュータ #queue #QISKIT

量子×クラウドはなぜ難しい？第4の壁：量子クラウドの待ち行列問題
https://qiita.com/imh1104/items/84dd7d5dee9884a008fa?utm_campaign=popular_items&utm_medium=feed&utm_source=popular_items

#qiita #Cloud #アーキテクチャ #量子コンピュータ #queue #QISKIT

Квантовые вычисления как инженерная проблема: почему «превосходство» не означает применимость

Когда в 2019 году была опубликована работа группы исследователей Google о так называемом квантовом превосходстве, само выражение почти мгновенно вышло за пределы научного контекста и стало частью популярного нарратива о скором вытеснении классических вычислений. Между тем, уже в оригинальной публикации речь шла о строго определённой задаче - выборке из распределения, искусственно сконструированного таким образом, чтобы затруднить классическое моделирование.

https://habr.com/ru/articles/1012450/

#квантовые_вычисления #суперпозиция #кубит #алгоритм_шора #qiskit #квантовые_технологии #квантовые_алгоритмы #квантовые_компьютеры #квантовый_компьютер #квантовый

Квантовые вычисления как инженерная проблема: почему «превосходство» не означает применимость

Когда в 2019 году была опубликована работа группы исследователей Google о так называемом квантовом превосходстве, само выражение почти мгновенно вышло за пределы научного контекста и стало частью популярного нарратива о скором вытеснении классических вычислений. Между тем, уже в оригинальной публикации речь шла о строго определённой задаче - выборке из распределения, искусственно сконструированного таким образом, чтобы затруднить классическое моделирование.

https://habr.com/ru/articles/1012450/

#квантовые_вычисления #суперпозиция #кубит #алгоритм_шора #qiskit #квантовые_технологии #квантовые_алгоритмы #квантовые_компьютеры #квантовый_компьютер #квантовый

Квантовые вычисления как инженерная проблема: почему «превосходство» не означает применимость

Когда в 2019 году была опубликована работа группы исследователей Google о так называемом квантовом превосходстве, само выражение почти мгновенно вышло за пределы научного контекста и стало частью популярного нарратива о скором вытеснении классических вычислений. Между тем, уже в оригинальной публикации речь шла о строго определённой задаче - выборке из распределения, искусственно сконструированного таким образом, чтобы затруднить классическое моделирование.

https://habr.com/ru/articles/1012450/

#квантовые_вычисления #суперпозиция #кубит #алгоритм_шора #qiskit #квантовые_технологии #квантовые_алгоритмы #квантовые_компьютеры #квантовый_компьютер #квантовый

Квантовые вычисления как инженерная проблема: почему «превосходство» не означает применимость

Когда в 2019 году была опубликована работа группы исследователей Google о так называемом квантовом превосходстве, само выражение почти мгновенно вышло за пределы научного контекста и стало частью популярного нарратива о скором вытеснении классических вычислений. Между тем, уже в оригинальной публикации речь шла о строго определённой задаче - выборке из распределения, искусственно сконструированного таким образом, чтобы затруднить классическое моделирование.

https://habr.com/ru/articles/1012450/

#квантовые_вычисления #суперпозиция #кубит #алгоритм_шора #qiskit #квантовые_технологии #квантовые_алгоритмы #квантовые_компьютеры #квантовый_компьютер #квантовый

I stress-tested Google’s new Colab MCP server with a real quantum workflow.

An AI agent took a blank Colab notebook and:
• installed dependencies
• fixed Qiskit compatibility issues
• ran a 15-point H2 scan
• submitted a real job to IBM Quantum hardware

This is where Colab gets interesting: not just notebook editing, but agent-operated cloud execution.

Article on @thepracticaldev
https://dev.to/axrisi/i-stress-tested-googles-colab-mcp-server-with-a-real-quantum-workflow-2oih

#AI #MCP #Colab #QuantumComputing #Qiskit #IBMQuantum #Python #CloudComputing

@gabor_samu Fascinating to see IBM Spectrum #LSF orchestrating classical HPC with #IBMQuantum
#QCD pipeline: HPC+SeeMPS preselections #BelleII noise moments → info-rich slices to Heron/Qiskit for squeezing/superradiance sims.
https://github.com/JavierMartinAlonso1980/qcd-vortex-entanglement
LSF realistic hybrid orchestrator? Can this workload run on #Qiskit / #IBMQuantum Heron QPUs to test squeezing channels + entanglement dominance under noise?
Collider data → #TensorNetworks → IBM QPUs
https://doi.org/10.5281/zenodo.18672796
#QuantumComputing

@gabor_samu Fascinating to see IBM Spectrum #LSF orchestrating classical HPC with #IBMQuantum
#QCD pipeline: HPC+SeeMPS preselections #BelleII noise moments → info-rich slices to Heron/Qiskit for squeezing/superradiance sims.
https://github.com/JavierMartinAlonso1980/qcd-vortex-entanglement
LSF realistic hybrid orchestrator? Can this workload run on #Qiskit / #IBMQuantum Heron QPUs to test squeezing channels + entanglement dominance under noise?
Collider data → #TensorNetworks → IBM QPUs
https://doi.org/10.5281/zenodo.18672796
#QuantumComputing

@gabor_samu Fascinating to see IBM Spectrum #LSF orchestrating classical HPC with #IBMQuantum
#QCD pipeline: HPC+SeeMPS preselections #BelleII noise moments → info-rich slices to Heron/Qiskit for squeezing/superradiance sims.
https://github.com/JavierMartinAlonso1980/qcd-vortex-entanglement
LSF realistic hybrid orchestrator? Can this workload run on #Qiskit / #IBMQuantum Heron QPUs to test squeezing channels + entanglement dominance under noise?
Collider data → #TensorNetworks → IBM QPUs
https://doi.org/10.5281/zenodo.18672796
#QuantumComputing

@gabor_samu Fascinating to see IBM Spectrum #LSF orchestrating classical HPC with #IBMQuantum
#QCD pipeline: HPC+SeeMPS preselections #BelleII noise moments → info-rich slices to Heron/Qiskit for squeezing/superradiance sims.
https://github.com/JavierMartinAlonso1980/qcd-vortex-entanglement
LSF realistic hybrid orchestrator? Can this workload run on #Qiskit / #IBMQuantum Heron QPUs to test squeezing channels + entanglement dominance under noise?
Collider data → #TensorNetworks → IBM QPUs
https://doi.org/10.5281/zenodo.18672796
#QuantumComputing

@gabor_samu Fascinating to see IBM Spectrum #LSF orchestrating classical HPC with #IBMQuantum
#QCD pipeline: HPC+SeeMPS preselections #BelleII noise moments → info-rich slices to Heron/Qiskit for squeezing/superradiance sims.
https://github.com/JavierMartinAlonso1980/qcd-vortex-entanglement
LSF realistic hybrid orchestrator? Can this workload run on #Qiskit / #IBMQuantum Heron QPUs to test squeezing channels + entanglement dominance under noise?
Collider data → #TensorNetworks → IBM QPUs
https://doi.org/10.5281/zenodo.18672796
#QuantumComputing

RE: https://mastodon.social/@jmma1980/115989420221925553

Step beyond toy models into a hybrid pipeline with real data. New repo: tensor-network prefiltering of #BelleII events (#SeeMPS, MPS/fermionic Gaussian states) selects entanglement‑relevant kinematics, then runs on #Qiskit / #IBMQuantum Heron to test squeezing channels and entanglement dominance under noise. From collider data → #TensorNetworks → IBM QPUs https://doi.org/10.5281/zenodo.18672796 https://github.com/JavierMartinAlonso1980/qcd-vortex-entanglement. #QCD #HighEnergyPhysics #QuantumEntanglement #SqueezedStates #MPS #BelleII #QuantumComputing

RE: https://mastodon.social/@jmma1980/115989420221925553

Step beyond toy models into a hybrid pipeline with real data. New repo: tensor-network prefiltering of #BelleII events (#SeeMPS, MPS/fermionic Gaussian states) selects entanglement‑relevant kinematics, then runs on #Qiskit / #IBMQuantum Heron to test squeezing channels and entanglement dominance under noise. From collider data → #TensorNetworks → IBM QPUs https://doi.org/10.5281/zenodo.18672796 https://github.com/JavierMartinAlonso1980/qcd-vortex-entanglement. #QCD #HighEnergyPhysics #QuantumEntanglement #SqueezedStates #MPS #BelleII #QuantumComputing

The future is quantum and so is BESSER.

Soon you’ll be able to model, generate, and accelerate quantum circuits directly within our platform. 🎬

This is just the beginning.

editor.besser-pearl.org

#Quantum #BESSER #QuantumComputing #DigitalEngineering #NoCode #qiskit #LowCod e #ModelDrivenEngineering hashtag#MDE

The future is quantum and so is BESSER.

Soon you’ll be able to model, generate, and accelerate quantum circuits directly within our platform. 🎬

This is just the beginning.

editor.besser-pearl.org

#Quantum #BESSER #QuantumComputing #DigitalEngineering #NoCode #qiskit #LowCod e #ModelDrivenEngineering hashtag#MDE

The future is quantum and so is BESSER.

Soon you’ll be able to model, generate, and accelerate quantum circuits directly within our platform. 🎬

This is just the beginning.

editor.besser-pearl.org

#Quantum #BESSER #QuantumComputing #DigitalEngineering #NoCode #qiskit #LowCod e #ModelDrivenEngineering hashtag#MDE

The future is quantum and so is BESSER.

Soon you’ll be able to model, generate, and accelerate quantum circuits directly within our platform. 🎬

This is just the beginning.

editor.besser-pearl.org

#Quantum #BESSER #QuantumComputing #DigitalEngineering #NoCode #qiskit #LowCod e #ModelDrivenEngineering hashtag#MDE

The future is quantum and so is BESSER.

Soon you’ll be able to model, generate, and accelerate quantum circuits directly within our platform. 🎬

This is just the beginning.

editor.besser-pearl.org

#Quantum #BESSER #QuantumComputing #DigitalEngineering #NoCode #qiskit #LowCod e #ModelDrivenEngineering hashtag#MDE

🎩🤹 Welcome to the magical world of #Qiskit, where mere mortals are expected to wrangle quantum circuits and operators as if they were coding wizards! 🤯✨ Meanwhile, your "intelligent" apps watch in awe, dreaming of a day when they too can understand what the heck an "extended quantum circuit" is. 🚀🔮
https://github.com/Qiskit/qiskit #QuantumComputing #QuantumCircuits #CodingWizards #TechMagic #HackerNews #ngated

🎩🤹 Welcome to the magical world of #Qiskit, where mere mortals are expected to wrangle quantum circuits and operators as if they were coding wizards! 🤯✨ Meanwhile, your "intelligent" apps watch in awe, dreaming of a day when they too can understand what the heck an "extended quantum circuit" is. 🚀🔮
https://github.com/Qiskit/qiskit #QuantumComputing #QuantumCircuits #CodingWizards #TechMagic #HackerNews #ngated

🎩🤹 Welcome to the magical world of #Qiskit, where mere mortals are expected to wrangle quantum circuits and operators as if they were coding wizards! 🤯✨ Meanwhile, your "intelligent" apps watch in awe, dreaming of a day when they too can understand what the heck an "extended quantum circuit" is. 🚀🔮
https://github.com/Qiskit/qiskit #QuantumComputing #QuantumCircuits #CodingWizards #TechMagic #HackerNews #ngated

🎩🤹 Welcome to the magical world of #Qiskit, where mere mortals are expected to wrangle quantum circuits and operators as if they were coding wizards! 🤯✨ Meanwhile, your "intelligent" apps watch in awe, dreaming of a day when they too can understand what the heck an "extended quantum circuit" is. 🚀🔮
https://github.com/Qiskit/qiskit #QuantumComputing #QuantumCircuits #CodingWizards #TechMagic #HackerNews #ngated

Qiskit open-source SDK for working with quantum computers

https://github.com/Qiskit/qiskit

#HackerNews #Qiskit #QuantumComputing #OpenSource #SDK #QuantumTech #GitHub

https://winbuzzer.com/2025/11/12/ibm-unveils-nighthawk-and-loon-quantum-processors-accelerating-quantum-roadmap-to-2026-xcxwbn

IBM Unveils Nighthawk and Loon Quantum Processors, Accelerating Quantum Roadmap to 2026

#QuantumComputing #IBM #QuantumAdvantage #Supercomputing #BigBlue #Nighthawk #Loon #Qiskit #Science #FutureTech #Research

https://winbuzzer.com/2025/11/12/ibm-unveils-nighthawk-and-loon-quantum-processors-accelerating-quantum-roadmap-to-2026-xcxwbn

IBM Unveils Nighthawk and Loon Quantum Processors, Accelerating Quantum Roadmap to 2026

#QuantumComputing #IBM #QuantumAdvantage #Supercomputing #BigBlue #Nighthawk #Loon #Qiskit #Science #FutureTech #Research

https://winbuzzer.com/2025/11/12/ibm-unveils-nighthawk-and-loon-quantum-processors-accelerating-quantum-roadmap-to-2026-xcxwbn

IBM Unveils Nighthawk and Loon Quantum Processors, Accelerating Quantum Roadmap to 2026

#QuantumComputing #IBM #QuantumAdvantage #Supercomputing #BigBlue #Nighthawk #Loon #Qiskit #Science #FutureTech #Research

https://winbuzzer.com/2025/11/12/ibm-unveils-nighthawk-and-loon-quantum-processors-accelerating-quantum-roadmap-to-2026-xcxwbn

IBM Unveils Nighthawk and Loon Quantum Processors, Accelerating Quantum Roadmap to 2026

#QuantumComputing #IBM #QuantumAdvantage #Supercomputing #BigBlue #Nighthawk #Loon #Qiskit #Science #FutureTech #Research

https://winbuzzer.com/2025/11/12/ibm-unveils-nighthawk-and-loon-quantum-processors-accelerating-quantum-roadmap-to-2026-xcxwbn

IBM Unveils Nighthawk and Loon Quantum Processors, Accelerating Quantum Roadmap to 2026

#QuantumComputing #IBM #QuantumAdvantage #Supercomputing #BigBlue #Nighthawk #Loon #Qiskit #Science #FutureTech #Research

Interested in learning more about #Quantum Computing? Consider the #qiskit learning school https://t.co/32UUrP4jJ0 (free)

🚀 What if your AI could predict the future like a quantum oracle?

Quantum AI isn’t just faster—it’s rewriting the laws of intelligence.
From 12x forecasting accuracy to decoding proteins in seconds, this changes everything.
Discover 7 breakthroughs set to reshape life by 2030.
⚛️ Don’t blink. This is the new OS of civilization.

🔍 Read now:
👉 https://medium.com/@rogt.x1997/7-quantum-ai-breakthroughs-that-could-redefine-humanity-by-2030-ee4ec4d2a193

#QuantumAI #AI2025 #TechFutures #Qiskit
https://medium.com/@rogt.x1997/7-quantum-ai-breakthroughs-that-could-redefine-humanity-by-2030-ee4ec4d2a193

Wolfgang und Kerstin berichten über die erste GITEX EUROPE in einer neuen Episode vom #DXPRS.

Es gab Anwendungsfälle für #KI, z. B. von ROBOPLANET mit Service-Katze (und anderen intelligenten Haushaltsgeräten), persönlichen KI-Assistenten von WAIYS oder dem Cyberdog 2 von Xiaomi.

Virtuelle Welten gab es u. a. beim Cyber- und Informationsraum der Bundeswehr. anabrid stellte ihren Analag-Rechner vor und IBM präsentierte #Quantencomputer mit #opensorce-QDK #qiskit.

https://data-express.letscast.fm/episode/dxprs0061-gitex-goes-europe

Wolfgang und Kerstin berichten über die erste GITEX EUROPE in einer neuen Episode vom #DXPRS.

Es gab Anwendungsfälle für #KI, z. B. von ROBOPLANET mit Service-Katze (und anderen intelligenten Haushaltsgeräten), persönlichen KI-Assistenten von WAIYS oder dem Cyberdog 2 von Xiaomi.

Virtuelle Welten gab es u. a. beim Cyber- und Informationsraum der Bundeswehr. anabrid stellte ihren Analag-Rechner vor und IBM präsentierte #Quantencomputer mit #opensorce-QDK #qiskit.

https://data-express.letscast.fm/episode/dxprs0061-gitex-goes-europe

YES!🚀 #Quantum optimization with fewer qubits!
We can now solve MaxCut for m=7000 using dramatically fewer qubits—matching or surpassing top classical solvers! 💡
Could this be a step toward near-term quantum advantage? 🔗 #QuantumComputing #Optimization #qiskit

#ITByte: #Qiskit is an open-source software development kit (#SDK) for working with quantum computers at the level of circuits, pulses, and algorithms. It provides tools for creating and manipulating quantum programs and running them on prototype quantum devices on IBM Quantum Experience or on simulators on a local computer.

Here is a quick overview to get started with your first #Quantum Program using Qiskit.

https://knowledgezone.co.in/posts/Quantum-Programming-using-Qiskit-63aa9e27bbc613109b2842b3

I'm very pleased to announce what some of us have been doing this Summer at IBM: a 3D-printed model of the
#IBM #Quantum System Two, with a built-in #RaspberryPi running #qiskit quantum software (including simulator).
You can actually write and run Quantum programs on it! How cool is that?
Still in beta, but...
https://github.com/JanLahmann/RasQberry-Two-3Dmodel

Quantum software stack is ready for business, says IBM

Higher level functions and managed services are starting to lower the bar to entry (free reg)

https://www.computing.co.uk/analysis/2024/quantum-software-stack-ready-business-ibm

#technews #quantum #ibm #qiskit #opensource

Qiskit and IBM’s New Quantum Innovations | The Gestalt IT Rundown: September 25, 2024

https://youtu.be/MZfZa_jF5q8

We’re happy to have Dr. Bob Sutor joining us this week on the Rundown, since he covers quantum and advanced computing for The Futurum Group. IBM made two important announcements in the quantum space this week. The first announcement was Qiskit, a quantum SDK that runs on Python for quantum computers. This promises to bring quantum compute to a more mainstream audience and converting the underlying code to Rust. This solution is much faster than competing solutions from Google, Amazon, and Quantinuuum. IBM is also putting together an app store for quantum applications and runtime functions, including from third-party developers. This matches the moves that we have seen in areas like cloud and AI, and serves to push IBM as the leader in quantum computing. This and more on The Rundown.

Apple Podcasts | Spotify | Overcast | Amazon Music | Audio | YouTube

1:57 – Qualcomm to Buy Intel?

Qualcomm is exploring a potential acquisition of Intel, a move that could strengthen both companies and enhance U.S. leadership in the chip industry, despite potential antitrust review. Intel, under CEO Pat Gelsinger, is pursuing strategic changes to boost its competitive edge, including expanding its manufacturing capabilities and investing in next-generation technologies. A successful deal would significantly broaden Qualcomm’s portfolio and position both companies for growth in the rapidly evolving AI and semiconductor markets.

Read More: Qualcomm Approached Intel About a Takeover in Recent Days

4:11 – Kioxia No Longer Planning IPO

Kioxia has postponed its planned IPO, which we discussed on the August 28 show, due to challenges in achieving its target valuation amid a broader market downturn. Despite recent improvements in memory chip prices, the company has been impacted by a slump in the chip market, which they had already previously delayed its IPO in 2020. Kioxia, with a 14% share in the flash memory market, remains focused on listing when market conditions improve.

Read More: Exclusive: Bain-backed chipmaker Kioxia scraps October IPO plan, sources say

6:42 – Announcements from Dreamforce

At its Dreamforce conference, Salesforce introduced Agentforce, a suite of AI-powered agents designed to streamline app development and improve customer experiences across industries. The platform’s low-code AI tools, new partnerships, and enhanced AI models aim to drive adoption of these autonomous agents, helping businesses automate tasks and unlock the full potential of their data. By integrating AI more deeply across its ecosystem, Salesforce seeks to differentiate its offering and support customers in modernizing operations and achieving higher ROI through scalable AI solutions. For more on this, let’s turn it over to The Futurum Group’s Keith Kirkpatrick who was at the event.

Read More: Dreamforce Announcements Focus on AI, Agentforce, and Cloud Enhancements

16:32 – Commvault Buys Clumio

Commvault just announced its acquisition of Clumio, an AWS data protection specialist we’ve previously discussed here on the Rundown. The acquisition enhances Commvault’s cyber resilience capabilities for cloud-native applications and allows the company to leverage Clumio’s innovations, including rapid access to Amazon S3 data during critical recovery operations, expanding its offerings for AWS-based businesses. Clumio’s expertise in protecting complex data sets will now reach a global scale through Commvault’s platform.

Read More: Commvault Accelerates Cyber Resilience Capabilities for AWS with Acquisition of Clumio

20:07 – CISA Wants to Say Ciao to Ivanti EOL Units

In a very telling move, CISA has made a statement telling customers to move off of Ivanti Cloud Services Appliance 4.6. The notice comes as yet another security update has been released and Ivanti is not porting it to versions prior to 5.0. The CISA has been very up front about exploits this year and Ivanti is no stranger to having issues with their underlying code quality.

Read More: Ivanti Releases Security Update for Cloud Services Appliance

22:47 – Veeam Acquires Alcion

Veeam announced today that they are acquiring Alcion. Alcion has focused on SaaS backups since being founded back in 2022. Veeam had led an investment round for Alcion in 2023 and Veeam had also acquired Kasten, which was the startup that had been founded previously by Alcion founders. In addition to the acquisition, Niraj Tolia will move into the vacant CTO role at Veeam to help guide the integration between all the products.

Read More: Veeam, the #1 Data Resilience Company, Appoints Niraj Tolia as Chief Technology Officer to Accelerate Innovation of Data Resilience as a Service

25:29 – Qiskit and IBM’s New Quantum Innovations

We’re happy to have Dr. Bob Sutor joining us this week on the Rundown, since he covers quantum and advanced computing for The Futurum Group. IBM made two important announcements in the quantum space this week. The first announcement was Qiskit, a quantum SDK that runs on Python for quantum computers. This promises to bring quantum compute to a more mainstream audience and converting the underlying code to Rust. This solution is much faster than competing solutions from Google, Amazon, and Quantinuuum. IBM is also putting togetther an app store for quantum applications and runtime functions, including from third-party developers. This matches the moves that we have seen in areas like cloud and AI, and serves to push IBM as the leader in quantum computing.

Read More: Quantum in Context: IBM Qiskit Boosts Software Development Speed

Read More: Microsoft unveils new quantum computing hybrid solution in Azure

34:27 – The Weeks Ahead

Networking Field Day Exclusive with Nokia – September 24

AI Data Infrastructure Field Day 1 – October 2 – 3

Commvault Shift – October 8 – 9

Security Field Day 12 – October 16 – 17

Cloud Field Day 21 – October 23 – 24

Gestalt IT and Tech Field Day are now part of The Futurum Group.

The Gestalt IT Rundown is your look at the IT news of the week. Be sure to subscribe to Gestalt IT on YouTube for even more weekly video content.

#Dreamforce #Qiskit #QuantumComputing #Rundown #1 #Alcion #Clumio #Commvault #GestaltIT #IBM #Intel #IntelBusiness #Qualcomm #Salesforce #SFoskett #TechFieldDay #TheFuturumGroup #Veeam

https://wp.me/p4YpUP-mDQ

#ITByte: A #Quantum #Circuit is a model for quantum computation, similar to classical circuits, in which a computation is a sequence of quantum gates, measurements, initializations of qubits to known values, and possibly other actions.

Developing your first #Quantum #Circuit - get started with Hands-on Programming for Quantum Computers using IBM #Qiskit.

https://knowledgezone.co.in/posts/Developing-your-first-quantum-circuit-62f898e2840e7b694a79fe15

It is not breaking news, that IBM is sun-setting #Qiskit 0.x soon. So if you are building on a version 0.x now, you should consider to migrate to newer versions. Upgrade path can be found here: https://docs.quantum.ibm.com/start/install

Official and up-to-date schedule is provided in Github: https://github.com/Qiskit/qiskit/milestones

#quantumcomputing #quantum

Generating random numbers from a variety of specific probability distributions shows us how the quantum state vector reflects the desired probability distribution, and the previous article showed how a variety of such distributions could be achieved. However, quantum computers can simulate a digital computer also. Even though bits are certain and qubits are uncertain, computing on a digital computer can be thought of like working with a special kind of probability distribution: one where there is a row on the state vector with a 100% probability, and all the rest are zero. This reflects how digital computers are deterministic. Let’s look at how we might perform digital computing operations on a quantum computer, sticking with high-school level maths.
https://aes.id.au/blog/1428
#increment #lesson #qiskit #quantum #quantumcomputing #technology

This is the second in a series of four articles based on my Jupyter Notebooks exploring quantum computing as a tool for generating random number distributions.

The first article showed how a quantum computer could be programmed to generate a uniform random distribution of two bits using operations on qubits. It was a pretty trivial algorithm, and compared with the complexity of generating pseudo-random numbers on a digital computer, showed the advantage of using quantum computers for this application. However, given that I discussed how quantum computers can manipulate probabilities, it’s natural to consider how other, non-uniform, random number distributions might be calculated using a quantum computer. As with the first article, I’m sticking with high-school level maths.

Bell state

A special type of quantum state is known as the Bell state. There are actually four Bell states, but for simplicity, we’ll just pick one. To put a two qubit quantum computer into a Bell state, we will manipulate it to have the state vector

$$\begin{bmatrix}
\frac{1}{\sqrt{2}} \\
0.0 \\
0.0 \\
\frac{1}{\sqrt{2}}
\end{bmatrix}$$

which means that a measurement will get either the |00> or |11> outcomes with equal probability, but the |01> and |10> outcomes won’t appear at all. Another way to think of this is flipping two coins, and having them always end up heads-heads or tails-tails, but never getting a heads-tails result.

To get this state vector, it’s not enough to use the H operation, but we need something called the CX operation.

CX operation

The CX operation can be thought of as a “constrained swap” operation which affects pairs of rows in the state vector specified by the states of two qubits (rather than specified by just one qubit, like we saw with the H operation). It will cause the values of those pairs of rows to swap, constrained to those pairs of possible outcomes where the first qubit specified is in the |1> state and that otherwise differ only by the value of the second qubit.

For example, if we start with the usual initial state vector for two qubits:

where the |00> outcome has a 100% probability, and now apply the CX operation against the right-most qubit then the left-most qubit, or CX(0,1) to use the Qiskit numbering for qubits, the state vector wouldn’t change at all, since the pair of rows where the right-most qubit is |1> are both the same, i.e. 0.0, so swapping doesn’t change anything.

However, if we firstly use the H operator on rows associated with the right-most qubit, or an H(0) operation, and then perform the same CX(0,1) operation, we get a more interesting result:

Swapping the rows made a change this time, and we have ended up with the Bell state that we were talking about above.

Implementing this on Qiskit

Now, let’s create a histogram of the results we get from performing this on a (simulated) quantum computer, and check that it does what we expect. We’ll use the same approach with Qiskit as we did last time. (You can grab the complete Python script from here, or just type in the code below.)

import numpy as npfrom qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAerfrom qiskit.visualization import plot_histogramimport matplotlib.pyplot as pltbackend = BasicAer.get_backend('qasm_simulator')q = QuantumRegister(2)   # We want to use 2 qubitsalgo = QuantumCircuit(q) # Readies us to construct an algorithm to run on the quantum computeralgo.h(0)          # Apply H operation on pairs of rows related to qubit 0algo.cx(0,1)       # Apply CX operation, constrained where qubit 0 is |1>algo.measure_all() # Measure the qubits and get some bitsresult = execute(algo, backend, shots=1000).result()plot_histogram(result.get_counts(algo))plt.show()

Yes, this is the random distribution we were hoping to get. It is just “00” and “11” with no “01” or “10” results.

RY operation

We’ve achieved a non-uniform distribution, but it’s not a very interesting one. It’s a 50-50 outcome, and we could have achieved that with 1 qubit. We didn’t really need 2 qubits. To create more interesting distributions, we will need another operation. Let’s take a look at the RY operation.

RY adjusts the pairs of state vector rows applying to a specified qubit, and adjusts them by a specified “angle”. If the angle is pi (𝜋), which is an amount in radians equivalent to 180 degrees, the adjustment results in a swap of values and flipping the sign of the first value (we’ll come back to this). But the swap is modified relative to the angle, so we can think of it like a “relative swap” operation.

Let’s have a look at at how it would work on the standard initial state vector, with the specific qubit being the right-most one (or, qubit 0), and for some different angles:

The first time the RY operation is used, it is given a specified angle of 0.0, and it does absolutely nothing to the state vector. This is correct – with an angle of 0.0, RY will not change anything.

Next, we can see that when the RY(𝜋, 0) operation happens, it swaps the values where the right-most qubit (qubit 0) differ, i.e. the first and second row, and the third and fourth row. In addition, it flips the sign on the first of each pair of rows. The first time RY happens, it simply moves the 100% outcome from |00> to |01>. The second time RY happens, it moves this outcome back to |00> and flips the sign to negative.

What does -100% mean? How can this be a probability? Well, each row of the state vector is a probability amplitude rather than a probability. If a probability amplitude is a real number, i.e. no imaginary component, you can turn it into its corresponding probability by just squaring it. -1.0 x -1.0 is 1.0, so -100% as a probability amplitude is equivalent to a 100% probability. Note that this isn’t just some oddity, but actually part of what makes quantum computers powerful.

The final application of the RY operation in the table is with a specified angle that is 𝜋/2 which corresponds to 90 degrees. It’s mid-way between 0.0 and 𝜋, and produces a result that is also mid-way between the previous results. Where the 0.0 angle didn’t move any of the probability amplitude values between the pairs, and the 𝜋 angle moved all of the probability amplitude values to the alternate row in each pair, the 𝜋/2 angle is halfway between those angles and it moved half the probability amplitude, in the same way the H operator did in the previous notebook.

In fact, we can pick an angle to give to the RY operation that will move a desired fraction of the probability amplitude value between the rows. To swap a fraction “f” of the value from the first row to the second, and bring the opposite fraction (i.e. 1-f) from the second row but with the sign flipped, you use the angle calculated by 2 x arcsin(√f). For our final application of RY above, it had the fraction f=1/2, and it turns out that 2 x arcsin(√(1/2)) = 𝜋/2 which is the angle used in the operation.

We can now use this knowledge to create a range of specific probability distributions for our random bits. The set of operations we have talked about so far – H, CX and RY – should allow us to create any probability distribution. For example, if we want to create a probability distribution where it is equally likely that any of the first three outcomes (|00>, |01>, and |10>) happen and yet the last outcome (|11>) shouldn’t happen, the state vector we’d want to create is:

$$\begin{bmatrix}
\sqrt{\frac{1}{3}} \\
\sqrt{\frac{1}{3}} \\
\sqrt{\frac{1}{3}} \\
0.0
\end{bmatrix}$$

A way to get this is to recognise that if we look at the state vector as two pairs of rows, the first pair of outcomes are twice as likely in total as the second pair of outcomes. We can use the RY operation to swap (the square root) of a third of the overall probability to the second pair. We can then use a sequence of H, RY, CX and RY operations to spread the probabilities within each pair. This looks like:

You can see here that after the H(0) operation, the first two rows have the values we want, but the final two rows had the desired values before the H(0). The operations following the H(0) have the effect of undoing the H(0) operation on the final two rows but leaving the first two rows alone. Note that the final two RY operations are opposite signs to each other, so they should cancel each other out, but a CX(1,0) operation has been done in the middle. This CX operation, in swapping the final two rows, has the effect of making it as if the first of the final two RY operations was also a negative angle for those rows, so instead of cancelling out (like happened on the first two rows), the two RY operations on those rows add together as if it was an RY operation of -𝜋/2. As we saw above, an RY operation with the angle 𝜋/2 is similar to an H operation, and with the negative angle, the RY operation acts to reverse the H.

Don’t worry if you didn’t fully follow that. This sort of procedure is called “amplitude embedding” or “state preparation”, and there are various algorithms to do this, many of which get quite esoteric. The above procedure was inspired by a paper by Mottonen, Vartiainen, Bergholm, and Salomaa. The main thing to note is that quantum computers allow arbitrary non-uniform distributions to be constructed.

Implementing this on Qiskit

Let’s test the above procedure and see if it does what we expect. (You can grab the complete Python script from here, or just type in the code below.)

import numpy as npfrom qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAerfrom qiskit.visualization import plot_histogramimport matplotlib.pyplot as pltbackend = BasicAer.get_backend('qasm_simulator')q = QuantumRegister(2)   # We want to use 2 qubitsangle1 = 2 * np.arcsin(np.sqrt(1.0/3.0))angle2 = np.pi / 4algo = QuantumCircuit(q) # Readies us to construct an algorithm to run on the quantum computeralgo.ry(angle1, 1)       # Apply RY operation to swap 1/3 of qubit 1's value algo.h(0)                # Apply H operation on pairs of rows related to qubit 0algo.ry(angle2, 0)       # Apply RY operation to perform a half of H on qubit 0algo.cx(1,0)             # Apply CX operation, constrained to where qubit 1=|1>algo.ry(-angle2, 0)      # Apply RY operation to undoing half of H on qubit 0algo.measure_all()       # Measure the qubits and get some bitsresult = execute(algo, backend, shots=1000).result()plot_histogram(result.get_counts(algo))              plt.show()

This is exactly what we were hoping to see. It is “00”, “01” and “10” split three ways, and with no “11” results.

In conclusion

We have added two more operations to our set, and seen how to use them on a quantum computer to create a variety of random distributions, such as the Bell state:

The next article will look at how to implement digital computing functions through operations on the state vector.

https://aes.id.au/blog/1395

#bellstate #lesson #qiskit #quantum #quantumcomputing #qubit #random #technology