push from SNAPKITTYWEST/black-hole-engine

IBM.qs

@@ -0,0 +1,66 @@
+//
+// Copyright (c) 2026 BEL ESPRIT D ACCORD TRUST HOLDINGS INC
+// All rights reserved.
+
+// BlackHoleEngine/IBM.qs
+// Hardware-specific: IBM Heron (heavy-hex, CX-based)
+namespace BlackHoleEngine.IBM {
+    open Microsoft.Quantum.Intrinsic;
+    open Microsoft.Quantum.Canon;
+    open BlackHoleEngine.Primitives;
+
+    operation IBMXX(
+        qubits : Qubit[],
+        i : Int, j : Int,
+        theta : Double,
+        couplingMap : (Int, Int)[]
+    ) : Unit is Adj + Ctl {
+        let path = ShortestPath(couplingMap, i, j);
+
+        for idx in 0..Length(path)-2 {
+            SWAP(qubits[path[idx]], qubits[path[idx+1]]);
+        }
+
+        let adj_i = path[Length(path)-2];
+        let adj_j = path[Length(path)-1];
+        CNOT(qubits[adj_i], qubits[adj_j]);
+        Rz(2.0 * theta, qubits[adj_j]);
+        CNOT(qubits[adj_i], qubits[adj_j]);
+
+        for idx in Length(path)-2..-1..0 {
+            SWAP(qubits[path[idx]], qubits[path[idx+1]]);
+        }
+    }
+
+    operation IBMHaydenPreskill(
+        qubits : Qubit[],
+        scrambleTime : Double,
+        couplings : Double[][],
+        fields : Double[],
+        couplingMap : (Int, Int)[]
+    ) : Unit is Adj + Ctl {
+        let n = Length(qubits);
+        let dt = scrambleTime / 10.0;
+        let steps = 10;
+
+        for _ in 1..steps {
+            for i in 0..n-1 {
+                Rz(2.0 * fields[i] * dt, qubits[i]);
+            }
+
+            for layer in GetXXLayers(n, couplings) {
+                for (i, j) in layer {
+                    let J = couplings[i][j];
+                    if (AbsD(J) > 1e-10) {
+                        IBMXX(qubits, i, j, 2.0 * J * dt, couplingMap);
+                    }
+                }
+            }
+        }
+    }
+
+    function ShortestPath(couplingMap : (Int, Int)[], src : Int, dst : Int) : Int[] {
+        // BFS on coupling graph (placeholder - use Qiskit routing in production)
+        return [src, dst];
+    }
+}

IonQ.qs

@@ -0,0 +1,67 @@
+//
+// Copyright (c) 2026 BEL ESPRIT D ACCORD TRUST HOLDINGS INC
+// All rights reserved.
+
+// BlackHoleEngine/IonQ.qs
+// Hardware-specific: IonQ Aria (all-to-all, native MS gate)
+namespace BlackHoleEngine.IonQ {
+    open Microsoft.Quantum.Intrinsic;
+    open Microsoft.Quantum.Canon;
+    open BlackHoleEngine.Primitives;
+
+    operation IonQXX(q1 : Qubit, q2 : Qubit, theta : Double) : Unit is Adj + Ctl {
+        Exp([PauliX, PauliX], theta, [q1, q2]);
+    }
+
+    operation IonQHaydenPreskill(
+        qubits : Qubit[],
+        scrambleTime : Double,
+        couplings : Double[][],
+        fields : Double[]
+    ) : Unit is Adj + Ctl {
+        let n = Length(qubits);
+        let dt = scrambleTime / 5.0;
+        let steps = 5;
+
+        for _ in 1..steps {
+            for i in 0..n-1 {
+                Rz(2.0 * fields[i] * dt, qubits[i]);
+            }
+
+            for layer in GetXXLayers(n, couplings) {
+                for (i, j) in layer {
+                    let J = couplings[i][j];
+                    if (AbsD(J) > 1e-10) {
+                        IonQXX(qubits[i], qubits[j], 2.0 * J * dt);
+                    }
+                }
+            }
+        }
+    }
+
+    operation IonQLindbladStep(
+        ancilla : Qubit,
+        qubits : Qubit[],
+        viol : ViolatingAssignment,
+        gamma_dt : Double
+    ) : Unit {
+        let sqrt_gamma = Sqrt(gamma_dt);
+        let theta = 2.0 * Arcsin(sqrt_gamma);
+
+        Ry(theta, ancilla);
+
+        let (va, vb, vc) = viol;
+        if (va) { X(qubits[0]); }
+        if (vb) { X(qubits[1]); }
+        if (vc) { X(qubits[2]); }
+
+        Controlled Z([ancilla, qubits[0], qubits[1]], qubits[2]);
+
+        if (va) { X(qubits[0]); }
+        if (vb) { X(qubits[1]); }
+        if (vc) { X(qubits[2]); }
+
+        let outcome = M(ancilla);
+        Reset(ancilla);
+    }
+}

LICENSE

@@ -0,0 +1,27 @@
+PROPRIETARY SOFTWARE LICENSE
+
+Copyright (c) 2026 BEL ESPRIT D ACCORD TRUST HOLDINGS INC
+All rights reserved.
+
+This software and associated documentation files (the "Software") are the
+exclusive property of BEL ESPRIT D ACCORD TRUST HOLDINGS INC. No part of
+this Software may be reproduced, distributed, transmitted, displayed,
+published, or broadcast in any form or by any means, including but not
+limited to photocopying, recording, or other electronic or mechanical
+methods, without the prior written permission of BEL ESPRIT D ACCORD TRUST
+HOLDINGS INC.
+
+Unauthorized copying, modification, merger, publication, distribution,
+sublicensing, sale, or use of this Software, in whole or in part, is
+strictly prohibited and may result in civil and criminal penalties.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+BEL ESPRIT D ACCORD TRUST HOLDINGS INC BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+For licensing inquiries, contact:
+BEL ESPRIT D ACCORD TRUST HOLDINGS INC

Phase2Engine.qs

@@ -0,0 +1,85 @@
+//
+// Copyright (c) 2026 BEL ESPRIT D ACCORD TRUST HOLDINGS INC
+// All rights reserved.
+
+// BlackHoleEngine/Phase2Engine.qs
+namespace BlackHoleEngine.Phase2 {
+    open Microsoft.Quantum.Intrinsic;
+    open Microsoft.Quantum.Canon;
+    open Microsoft.Quantum.Measurement;
+    open Microsoft.Quantum.Arrays;
+    open Microsoft.Quantum.Math;
+    open BlackHoleEngine.Primitives;
+
+    @EntryPoint()
+    operation RunPhase2Collapse(
+        nQubits : Int,
+        clauses : (Int, Int, Int)[],
+        violations : ViolatingAssignment[],
+        gamma_dt : Double,
+        delta : Double,
+        scrambleInterval : Int,
+        scrambleTime : Double,
+        maxSteps : Int
+    ) : (Bool[], Double) {
+
+        use qubits = Qubit[nQubits];
+        use ancilla = Qubit();
+
+        ApplyToEach(H, qubits);
+
+        let m = Length(clauses);
+        let couplings = GenerateCouplings(nQubits);
+        let fields = GenerateFields(nQubits);
+
+        mutable step = 0;
+        mutable scrambleCount = 0;
+        mutable energy = 1.0;
+
+        while (step < maxSteps and energy > delta) {
+            for idx in 0..m-1 {
+                let (a, b, c) = clauses[idx];
+                let viol = violations[idx];
+                LindbladStepClause(ancilla, [qubits[a], qubits[b], qubits[c]], viol, gamma_dt);
+            }
+
+            set energy = MeasureEnergy(qubits, clauses, violations);
+
+            set scrambleCount += 1;
+            if (scrambleCount >= scrambleInterval and energy < 2.0 * delta) {
+                HaydenPreskillScrambler(qubits, scrambleTime, couplings, fields);
+                set scrambleCount = 0;
+                set energy = MeasureEnergy(qubits, clauses, violations);
+            }
+
+            set step += 1;
+        }
+
+        let result = MultiM(qubits);
+        let bits = ResultArrayAsBoolArray(result);
+
+        ResetAll(qubits);
+        Reset(ancilla);
+
+        return (bits, energy);
+    }
+
+    function GenerateCouplings(n : Int) : Double[][] {
+        let J = 1.0 / IntAsDouble(n);
+        mutable matrix = new Double[n][n];
+        for i in 0..n-1 {
+            for j in 0..n-1 {
+                set matrix[i][j] = if i < j then J else 0.0;
+            }
+        }
+        return matrix;
+    }
+
+    function GenerateFields(n : Int) : Double[] {
+        mutable fields = new Double[n];
+        for i in 0..n-1 {
+            set fields[i] = 0.5; // deterministic for reproducibility
+        }
+        return fields;
+    }
+}

Quantinuum.qs

@@ -0,0 +1,74 @@
+//
+// Copyright (c) 2026 BEL ESPRIT D ACCORD TRUST HOLDINGS INC
+// All rights reserved.
+
+// BlackHoleEngine/Quantinuum.qs
+// Hardware-specific: Quantinuum H1/H2 (all-to-all, native ZZ)
+namespace BlackHoleEngine.Quantinuum {
+    open Microsoft.Quantum.Intrinsic;
+    open Microsoft.Quantum.Canon;
+    open BlackHoleEngine.Primitives;
+
+    operation QuantinuumXX(q1 : Qubit, q2 : Qubit, theta : Double) : Unit is Adj + Ctl {
+        within {
+            H(q1); H(q2);
+        } apply {
+            Exp([PauliZ, PauliZ], theta, [q1, q2]);
+        }
+    }
+
+    operation QuantinuumHaydenPreskill(
+        qubits : Qubit[],
+        scrambleTime : Double,
+        couplings : Double[][],
+        fields : Double[]
+    ) : Unit is Adj + Ctl {
+        let n = Length(qubits);
+        let dt = scrambleTime / 5.0;
+        let steps = 5;
+
+        for _ in 1..steps {
+            for i in 0..n-1 {
+                Rz(2.0 * fields[i] * dt, qubits[i]);
+            }
+
+            for layer in GetXXLayers(n, couplings) {
+                for (i, j) in layer {
+                    let J = couplings[i][j];
+                    if (AbsD(J) > 1e-10) {
+                        QuantinuumXX(qubits[i], qubits[j], 2.0 * J * dt);
+                    }
+                }
+            }
+        }
+    }
+
+    operation QuantinuumLindbladStep(
+        ancilla : Qubit,
+        qubits : Qubit[],
+        viol : ViolatingAssignment,
+        gamma_dt : Double
+    ) : Unit {
+        let sqrt_gamma = Sqrt(gamma_dt);
+        let theta = 2.0 * Arcsin(sqrt_gamma);
+
+        Ry(theta, ancilla);
+
+        let (va, vb, vc) = viol;
+        if (va) { X(qubits[0]); }
+        if (vb) { X(qubits[1]); }
+        if (vc) { X(qubits[2]); }
+
+        // Quantinuum has high-fidelity CCZ
+        CCZ(ancilla, qubits[0], qubits[1]);
+        CCZ(ancilla, qubits[0], qubits[2]);
+        CCZ(ancilla, qubits[1], qubits[2]);
+
+        if (va) { X(qubits[0]); }
+        if (vb) { X(qubits[1]); }
+        if (vc) { X(qubits[2]); }
+
+        let outcome = M(ancilla);
+        Reset(ancilla);
+    }
+}

QuantumPrimitives.qs

@@ -0,0 +1,151 @@
+//
+// Copyright (c) 2026 BEL ESPRIT D ACCORD TRUST HOLDINGS INC
+// All rights reserved.
+
+// BlackHoleEngine/QuantumPrimitives.qs
+namespace BlackHoleEngine.Primitives {
+    open Microsoft.Quantum.Intrinsic;
+    open Microsoft.Quantum.Canon;
+    open Microsoft.Quantum.Arithmetic;
+    open Microsoft.Quantum.Measurement;
+    open Microsoft.Quantum.Arrays;
+    open Microsoft.Quantum.Convert;
+    open Microsoft.Quantum.Math;
+
+    newtype ViolatingAssignment = (Bool, Bool, Bool);
+
+    operation ApplyClauseProjector(
+        qubits : Qubit[],
+        viol : ViolatingAssignment
+    ) : Unit is Adj + Ctl {
+        let (va, vb, vc) = viol;
+        within {
+            if va { X(qubits[0]); }
+            if vb { X(qubits[1]); }
+            if vc { X(qubits[2]); }
+        } apply {
+            // Projector |000><000| applied via controlled rotation on ancilla
+        }
+    }
+
+    operation HadamardTestClause(
+        ancilla : Qubit,
+        qubits : Qubit[],
+        viol : ViolatingAssignment
+    ) : (Double, Double) {
+        let (va, vb, vc) = viol;
+
+        within {
+            H(ancilla);
+        } apply {
+            Controlled ApplyClauseProjector([ancilla], (qubits, viol));
+        }
+
+        H(ancilla);
+        let real = M(ancilla) == Zero ? 1.0 | -1.0;
+        Reset(ancilla);
+
+        within {
+            H(ancilla);
+            S(ancilla);
+        } apply {
+            Controlled ApplyClauseProjector([ancilla], (qubits, viol));
+        }
+
+        H(ancilla);
+        let imag = M(ancilla) == Zero ? 1.0 | -1.0;
+        Reset(ancilla);
+        return (real, imag);
+    }
+
+    operation LindbladStepClause(
+        ancilla : Qubit,
+        qubits : Qubit[],
+        viol : ViolatingAssignment,
+        gamma_dt : Double
+    ) : Unit is Adj + Ctl {
+        let sqrt_gamma = Sqrt(gamma_dt);
+
+        within {
+            Ry(2.0 * Arcsin(sqrt_gamma), ancilla);
+        } apply {
+            Controlled ApplyClauseProjector([ancilla], (qubits, viol));
+        }
+
+        let outcome = M(ancilla);
+        Reset(ancilla);
+    }
+
+    operation HaydenPreskillScrambler(
+        qubits : Qubit[],
+        scrambleTime : Double,
+        couplings : Double[][],
+        fields : Double[]
+    ) : Unit is Adj + Ctl {
+        let n = Length(qubits);
+        let dt = scrambleTime / 10.0;
+        let steps = 10;
+
+        for _ in 1..steps {
+            for i in 0..n-1 {
+                Rz(2.0 * fields[i] * dt, qubits[i]);
+            }
+
+            for layer in GetXXLayers(n, couplings) {
+                for (i, j) in layer {
+                    let J = couplings[i][j];
+                    if (AbsD(J) > 1e-10) {
+                        CNOT(qubits[i], qubits[j]);
+                        Rz(2.0 * J * dt, qubits[j]);
+                        CNOT(qubits[i], qubits[j]);
+                    }
+                }
+            }
+        }
+    }
+
+    function GetXXLayers(n : Int, couplings : Double[][]) : (Int, Int)[][] {
+        mutable layers = [];
+        for i in 0..n-1 {
+            for j in i+1..n-1 {
+                if (AbsD(couplings[i][j]) > 1e-10) {
+                    mutable placed = false;
+                    for layerIdx in 0..Length(layers)-1 {
+                        mutable conflict = false;
+                        for (a, b) in layers[layerIdx] {
+                            if (a == i or a == j or b == i or b == j) {
+                                set conflict = true;
+                            }
+                        }
+                        if (not conflict) {
+                            set layers[layerIdx] += [(i, j)];
+                            set placed = true;
+                        }
+                    }
+                    if (not placed) {
+                        set layers += [[(i, j)]];
+                    }
+                }
+            }
+        }
+        return layers;
+    }
+
+    operation MeasureEnergy(
+        qubits : Qubit[],
+        clauses : (Int, Int, Int)[],
+        violations : ViolatingAssignment[]
+    ) : Double {
+        mutable total = 0.0;
+        use ancilla = Qubit();
+
+        for idx in 0..Length(clauses)-1 {
+            let (a, b, c) = clauses[idx];
+            let viol = violations[idx];
+            let (re, im) = HadamardTestClause(ancilla, [qubits[a], qubits[b], qubits[c]], viol);
+            set total += re;
+        }
+
+        return total;
+    }
+}

README.md

@@ -0,0 +1,245 @@
+# 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.
+
+```text
+ALGORITHM
+    ↓
+SPECIFIC HARDWARE
+    ↓
+SPECIFIC CONSTRAINTS
+    ↓
+SPECIFIC RESULTS
+```
+
+The algorithm becomes entangled with the hardware.
+
+The Black Hole Engine separates them.
+
+---
+
+# Architecture
+
+```text
+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.
+
+```text
+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.
+
+```text
+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
+
+```text
+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.
+
+```text
+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
+
+```bash
+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`](LICENSE) for the governing terms.
+
+---
+
+```text
+phase is information.
+measurement is extraction.
+the substrate matters.
+own the computation.
+```

run_phase2.py

@@ -0,0 +1,58 @@
+#
+# Copyright (c) 2026 BEL ESPRIT D ACCORD TRUST HOLDINGS INC
+# All rights reserved.
+
+# run_phase2.py — Classical driver for Phase 2 Lindblad Collapse
+import numpy as np
+
+def run_on_hardware(backend: str = "qsharp.simulator"):
+    """Run Phase 2 on specified backend."""
+    import qsharp
+    from BlackHoleEngine.Phase2 import RunPhase2Collapse
+
+    qsharp.config.target = backend
+
+    # 3-SAT instance: (x0 | x1 | x2) & (~x0 | x1 | ~x2)
+    n = 3
+    clauses = [(0, 1, 2), (0, 1, 2)]
+    violations = [(False, False, False), (True, False, True)]
+
+    gamma_dt = 0.01
+    delta = 1e-4
+    scramble_interval = 5
+    scramble_time = 5.0 * np.log(2**n)
+    max_steps = 1000
+
+    print(f"Running Phase 2 on {backend}...")
+    print(f"n={n}, m={len(clauses)}, gamma_dt={gamma_dt}, delta={delta}")
+
+    result = RunPhase2Collapse.simulate(
+        nQubits=n,
+        clauses=clauses,
+        violations=violations,
+        gamma_dt=gamma_dt,
+        delta=delta,
+        scrambleInterval=scramble_interval,
+        scrambleTime=scramble_time,
+        maxSteps=max_steps
+    )
+
+    solution, final_energy = result
+    print(f"Solution: {solution}")
+    print(f"Final energy: {final_energy}")
+
+    for (a, b, c), (va, vb, vc) in zip(clauses, violations):
+        vals = (solution[a], solution[b], solution[c])
+        violated = (vals == (va, vb, vc))
+        print(f"  Clause ({a},{b},{c}): assignment {vals}, violated={violated}")
+
+    return solution, final_energy
+
+
+if __name__ == "__main__":
+    run_on_hardware("qsharp.simulator")
+    # run_on_hardware("ionq.simulator")
+    # run_on_hardware("ionq.qpu")
+    # run_on_hardware("quantinuum.simulator")
+    # run_on_hardware("quantinuum.qpu")
+    # run_on_hardware("ibm.heron")