Spaces:
Sleeping
Sleeping
File size: 5,500 Bytes
5543795 8ddf71d 5543795 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | from __future__ import annotations
from typing import List, Sequence, Tuple
import networkx as nx
import numpy as np
def select_boundary_qubits(
boundary_nodes: Sequence[int],
max_qubits: int,
) -> Tuple[List[int], np.ndarray]:
"""
Wähle bis zu ``max_qubits`` Randknoten als Qubit-Standorte und ordne
allen Randknoten einen Qubit-Cluster zu.
Rückgabe
--------
qubit_nodes : Liste der Randknoten, an denen Qubits sitzen.
cluster_idx : Array der Länge len(boundary_nodes); cluster_idx[j] ist
der Index des Qubits (0 .. len(qubit_nodes)-1), dem
Randknoten boundary_nodes[j] zugeordnet ist.
"""
bnodes = list(boundary_nodes)
nB = len(bnodes)
if nB == 0:
raise ValueError("boundary_nodes darf nicht leer sein.")
if max_qubits <= 0:
raise ValueError("max_qubits muss > 0 sein.")
n_q = min(max_qubits, nB)
# equidistante Auswahl entlang der Randliste
indices = np.linspace(0, nB - 1, num=n_q, dtype=int)
qubit_nodes = [bnodes[i] for i in indices]
# Cluster-Zuordnung: ordne jeden Randknoten dem nächstgelegenen Qubit-Index zu
cluster_idx = np.empty(nB, dtype=int)
for j in range(nB):
cluster_idx[j] = int(np.argmin(np.abs(indices - j)))
return qubit_nodes, cluster_idx
def _pauli_matrices() -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
"""Gib (sx, sy, sz, id2) als komplexe 2x2-Matrizen zurück."""
sx = np.array([[0, 1], [1, 0]], dtype=complex)
sy = np.array([[0, -1j], [1j, 0]], dtype=complex)
sz = np.array([[1, 0], [0, -1]], dtype=complex)
id2 = np.eye(2, dtype=complex)
return sx, sy, sz, id2
def build_qubit_hamiltonian_xy(
G_real: nx.Graph,
qubit_nodes: Sequence[int],
J: float = 1.0,
hz: float = 0.0,
) -> np.ndarray:
"""
Baue einen einfachen XY-Hamiltonoperator auf einem Qubit-Netzwerk.
H = sum_(i,j in E_bath) J * (sx_i sx_j + sy_i sy_j) + sum_i hz * sz_i
Die Kanten E_bath werden aus dem REAL-Graphen G_real entnommen,
indem nur Kanten zwischen ausgewählten qubit_nodes berücksichtigt werden.
Falls dadurch kein Netzwerk entsteht, wird ersatzweise eine lineare
Kette 0-1-2-...-n-1 verwendet.
"""
n = len(qubit_nodes)
if n <= 0:
raise ValueError("Es müssen mindestens ein Qubit vorhanden sein.")
dim = 2**n
sx, sy, sz, id2 = _pauli_matrices()
# Operator-Hebung auf n Qubits
def op_on(i: int, op: np.ndarray) -> np.ndarray:
ops = [id2] * n
ops[i] = op
out = ops[0]
for k in range(1, n):
out = np.kron(out, ops[k])
return out
H = np.zeros((dim, dim), dtype=complex)
# Kanten im Bad: nur Kanten zwischen qubit_nodes aus REAL-Graphen
idx_map = {node: i for i, node in enumerate(qubit_nodes)}
edges: List[Tuple[int, int]] = []
for u, v in G_real.edges():
if u in idx_map and v in idx_map:
i, j = idx_map[u], idx_map[v]
if i != j:
edges.append((min(i, j), max(i, j)))
# Duplikate entfernen
edges = sorted(set(edges))
# Fallback: lineare Kette, falls keine Kanten im Randnetzwerk
if not edges and n > 1:
edges = [(i, i + 1) for i in range(n - 1)]
# XY-Kopplungen
for i, j in edges:
H += J * (op_on(i, sx) @ op_on(j, sx) + op_on(i, sy) @ op_on(j, sy))
# Lokale z-Felder
if abs(hz) > 0.0:
for i in range(n):
H += hz * op_on(i, sz)
return H
def ground_state_sz_covariance(psi0: np.ndarray, n: int) -> Tuple[np.ndarray, np.ndarray]:
"""
Berechne Erwartungswerte ⟨σ_z_i⟩ und Kovarianzmatrix Cov(σ_z_i, σ_z_j)
im Grundzustand psi0 eines n-Qubit-Systems.
Wir nutzen, dass σ_z in der Computational-Basis diagonal ist und
summieren über alle Basiszustände |s⟩ mit p(s) = |psi0[s]|^2.
"""
dim = 2**n
if psi0.shape[0] != dim:
raise ValueError(f"psi0 hat Dimension {psi0.shape[0]}, erwartet {dim}.")
sz_expect = np.zeros(n, dtype=float)
szsz = np.zeros((n, n), dtype=float)
for state in range(dim):
amp = psi0[state]
p = float((amp.conj() * amp).real)
if p < 1e-16:
continue
# z-Eigenwerte pro Qubit im Computational-Basiszustand `state`
z_vals = np.empty(n, dtype=int)
for i in range(n):
bit = (state >> i) & 1
z_vals[i] = 1 if bit == 0 else -1
sz_expect += p * z_vals
for i in range(n):
zi = z_vals[i]
for j in range(n):
szsz[i, j] += p * zi * z_vals[j]
C = szsz - np.outer(sz_expect, sz_expect)
return sz_expect, C
def embed_qubit_covariance_to_boundary(
C_qubit: np.ndarray,
cluster_idx: np.ndarray,
) -> np.ndarray:
"""
Hebe die Qubit-Kovarianzmatrix C_qubit (n_q x n_q) auf alle Randknoten an,
indem jeder Randknoten dem Cluster seines Qubits zugeordnet wird.
C_full[i,j] = C_qubit[k(i), k(j)], wobei k(i) = cluster_idx[i].
"""
n_q = C_qubit.shape[0]
nB = int(cluster_idx.shape[0])
C_full = np.zeros((nB, nB), dtype=float)
for i in range(nB):
ki = int(cluster_idx[i])
for j in range(nB):
kj = int(cluster_idx[j])
if 0 <= ki < n_q and 0 <= kj < n_q:
C_full[i, j] = float(C_qubit[ki, kj])
# numerische Stabilisierung der Diagonale
C_full += 1e-6 * np.eye(nB, dtype=float)
return C_full
|