Snapkitty/black-hole-engine

Black Hole Engine

Multi-Backend Quantum Phase Estimation

Quantum computation as an execution substrate. Not a metaphor.

The Black Hole Engine explores quantum phase estimation across multiple hardware backends.

The system targets IBM superconducting qubits, IonQ trapped ions, and Quantinuum H-series processors through a unified Q# abstraction layer.

The central question:

Can quantum phase estimation be treated as a general computation primitive, independent of the specific quantum hardware executing it?

---

The Problem

Quantum computation is typically presented as backend-specific.

ALGORITHM
    ↓
SPECIFIC HARDWARE
    ↓
SPECIFIC CONSTRAINTS
    ↓
SPECIFIC RESULTS

The algorithm becomes entangled with the hardware.

The Black Hole Engine separates them.

---

Architecture

QUANTUM STATE
     ↓
CIRCUIT (backend-agnostic)
     ↓
PHASE ESTIMATION
     ↓
BACKEND SELECTION
     ↓
     ├── IBM (superconducting)
     ├── IonQ (trapped ion)
     └── Quantinuum (H-series)
     ↓
MEASUREMENT
     ↓
VERIFICATION

The same algorithm.

Different physical substrates.

Comparable results.

---

Components

File	Purpose
QuantumPrimitives.qs	Core quantum operations and abstractions
Phase2Engine.qs	Phase estimation engine (Phase 2 protocol)
IBM.qs	IBM superconducting backend targeting
IonQ.qs	IonQ trapped ion backend targeting
Quantinuum.qs	Quantinuum H-series backend targeting
run_phase2.py	Python orchestration for Phase 2 execution

---

Phase Estimation

Phase estimation extracts eigenvalues from unitary operators.

UNITARY OPERATOR U
        ↓
EIGENSTATE |ψ⟩
        ↓
U|ψ⟩ = e^(2πiθ)|ψ⟩
        ↓
ESTIMATE θ

The Black Hole Engine implements this as a computation primitive.

The name comes from the connection between phase estimation and black hole information theory.

Information encoded in a quantum phase is:

• present
• extractable
• but not directly observable without the right measurement basis

---

Backend Independence

Each backend has different:

• gate sets
• connectivity constraints
• error characteristics
• measurement fidelity

The Q# layer abstracts these differences.

The backend-specific files handle transpilation.

Q# CIRCUIT (logical)
      ↓
TRANSPILATION
      ↓
NATIVE GATE SET
      ↓
HARDWARE EXECUTION
      ↓
RAW MEASUREMENT
      ↓
POST-PROCESSING
      ↓
PHASE ESTIMATE

The same logical circuit produces comparable phase estimates regardless of which physical system executes it.

---

Technologies

Q#          →  Quantum circuit description and simulation
Python      →  Orchestration and result analysis

Q# was chosen because it provides:

• a type system for quantum operations
• simulation capabilities for development
• targeting to multiple physical backends
• a separation between logical and physical circuits

---

The Quantum Substrate

The Black Hole Engine treats quantum computation the way XREX Unified Attention treats GPU computation.

Not as a destination.

As a substrate.

CLASSICAL COMPUTATION
     ↓
what happens here is well understood

QUANTUM COMPUTATION
     ↓
what happens here is the research question

The engine does not assume quantum computation is better.

It investigates what quantum computation makes possible that classical computation does not.

---

Research Philosophy

Phase is information

A quantum phase encodes information that is physically real but not directly observable.

Extracting that information requires specific measurement strategies.

Hardware is not neutral

Different quantum hardware produces different error profiles.

The same algorithm on different backends is not the same computation.

Understanding those differences is part of the research.

Simulation is not execution

Simulating a quantum circuit on a classical computer tells you what the circuit computes.

It does not tell you what the hardware does when it executes that circuit.

The gap between simulation and execution is where the interesting physics lives.

---

Getting Started

git clone https://github.com/SNAPKITTYWEST/black-hole-engine.git
cd black-hole-engine

# Run Phase 2 estimation (simulation mode)
python run_phase2.py

# Explore quantum primitives
cat QuantumPrimitives.qs

Requires: .NET SDK, Q# development kit, Python 3.10+.

---

Status

Research / Experimental

The engine explores quantum phase estimation as a computation primitive.

Backend targeting requires access to the respective quantum hardware platforms.

Simulation mode is available for development and verification.

---

Copyright

Copyright BEL ESPRIT D ACCORD TRUST HOLDINGS INC.

See LICENSE for the governing terms.

---

phase is information.
measurement is extraction.
the substrate matters.
own the computation.