Snapkitty/quantum-kernel

1# lattice_surgery.jl — Map CZ Layers to Smooth/Rough Defect Operations2 3module LatticeSurgery4 5using LinearAlgebra6 7export LatticeSurgeryOp, DefectPair, DefectTracker8export logical_cz, defect_braid_to_circuit_ops, syndrome_extraction_ops9export allocate_defect_pair!, braid_defects!10 11# ═══════════════════════════════════════════════════════════════════════12# Defect Types13# ═══════════════════════════════════════════════════════════════════════14 15struct DefectPair16    id::String17    anyon_type::Symbol18    smooth_defect::Tuple{Int,Int}19    rough_defect::Tuple{Int,Int}20    braid_trajectory::Vector{Tuple{Int,Int}}21end22 23mutable struct DefectTracker24    defects::Dict{String, DefectPair}25    fusion_rules::Dict{Tuple{Symbol,Symbol}, Vector{Symbol}}26    lattice_size::Tuple{Int,Int}27    time_step::Int28end29 30function DefectTracker(lattice_size::Tuple{Int,Int}=(20,20))31    rules = Dict(32        (:fibonacci, :fibonacci) => [:vacuum, :fibonacci],33        (:ising, :ising) => [:vacuum, :fermion],34        (:toric, :toric) => [:vacuum],35    )36    DefectTracker(Dict{String, DefectPair}(), rules, lattice_size, 0)37end38 39struct LatticeSurgeryOp40    op_type::Symbol41    defect_ids::Vector{String}42    basis::Symbol43    ancilla_id::Union{String, Nothing}44end45 46# ═══════════════════════════════════════════════════════════════════════47# Defect Allocation & Braiding48# ═══════════════════════════════════════════════════════════════════════49 50function allocate_defect_pair!(tracker::DefectTracker, id::String, anyon_type::Symbol,51                                smooth_pos::Tuple{Int,Int}, rough_pos::Tuple{Int,Int})52    pair = DefectPair(id, anyon_type, smooth_pos, rough_pos, [smooth_pos, rough_pos])53    tracker.defects[id] = pair54    return pair55end56 57function braid_defects!(tracker::DefectTracker, id1::String, id2::String, direction::Int)58    d1 = tracker.defects[id1]59    d2 = tracker.defects[id2]60    new_traj1 = vcat(d1.braid_trajectory, [d2.rough_defect])61    new_traj2 = vcat(d2.braid_trajectory, [d1.rough_defect])62    tracker.defects[id1] = DefectPair(d1.id, d1.anyon_type, d1.smooth_defect,63                                       d2.rough_defect, new_traj1)64    tracker.defects[id2] = DefectPair(d2.id, d2.anyon_type, d2.smooth_defect,65                                       d1.rough_defect, new_traj2)66    tracker.time_step += 167end68 69# ═══════════════════════════════════════════════════════════════════════70# Logical CZ via Lattice Surgery71# ═══════════════════════════════════════════════════════════════════════72 73"""74    logical_cz(tracker, id1, id2)75 76Implement logical CZ between two defect-encoded qubits:771. Merge rough defects (Z-basis merge)782. Measure joint Z operator793. Split defects80"""81function logical_cz(tracker::DefectTracker, id1::String, id2::String)::Vector{LatticeSurgeryOp}82    ops = LatticeSurgeryOp[]83 84    push!(ops, LatticeSurgeryOp(:merge, [id1, id2], :Z, nothing))85 86    ancilla = "ancilla_$(id1)_$(id2)"87    allocate_defect_pair!(tracker, ancilla, :toric, (0,0), (0,0))88    push!(ops, LatticeSurgeryOp(:measure, [id1, id2, ancilla], :Z, ancilla))89 90    push!(ops, LatticeSurgeryOp(:split, [id1, id2], :Z, nothing))91 92    return ops93end94 95# ═══════════════════════════════════════════════════════════════════════96# Defect Braiding → Circuit Ops97# ═══════════════════════════════════════════════════════════════════════98 99const HERON_EDGES_0 = [100    (0, 1), (1, 2),101    (0, 3), (1, 3), (1, 4), (2, 4), (2, 5),102    (3, 4), (4, 5), (5, 6),103    (3, 7), (4, 7), (4, 8), (5, 8), (5, 9), (6, 9),104    (7, 8), (8, 9)105]106 107struct CircuitOp108    gate::String109    qubits::Vector{Int}110end111 112"""113    defect_braid_to_circuit_ops(bw_gens, bw_edges, n_qubits)114 115Compile braid word to physical circuit ops using defect trajectories.116Each braid generator → defect exchange via lattice surgery moves.117"""118function defect_braid_to_circuit_ops(generators::Vector{Int}, edge_indices::Vector{Int},119                                      n_qubits::Int)::Vector{CircuitOp}120    ops = CircuitOp[]121 122    for (gen, edge_idx) in zip(generators, edge_indices)123        if edge_idx > length(HERON_EDGES_0)124            continue125        end126        q1, q2 = HERON_EDGES_0[edge_idx]127        if q1 >= n_qubits || q2 >= n_qubits128            continue129        end130 131        if gen > 0132            push!(ops, CircuitOp("H", [q1]))133            push!(ops, CircuitOp("CX", [q1, q2]))134            push!(ops, CircuitOp("H", [q2]))135            push!(ops, CircuitOp("CX", [q2, q1]))136            push!(ops, CircuitOp("H", [q1]))137            push!(ops, CircuitOp("CX", [q1, q2]))138            push!(ops, CircuitOp("H", [q2]))139        else140            push!(ops, CircuitOp("H", [q2]))141            push!(ops, CircuitOp("CX", [q2, q1]))142            push!(ops, CircuitOp("H", [q1]))143            push!(ops, CircuitOp("CX", [q1, q2]))144            push!(ops, CircuitOp("H", [q2]))145            push!(ops, CircuitOp("CX", [q2, q1]))146            push!(ops, CircuitOp("H", [q1]))147        end148    end149 150    return ops151end152 153# ═══════════════════════════════════════════════════════════════════════154# Syndrome Extraction155# ═══════════════════════════════════════════════════════════════════════156 157function syndrome_extraction_ops(tracker::DefectTracker, basis::Symbol=:Z)::Vector{CircuitOp}158    ops = CircuitOp[]159 160    for (id, defect) in tracker.defects161        q = basis == :Z ? defect.rough_defect[1] : defect.smooth_defect[1]162        push!(ops, CircuitOp("H", [q]))163        push!(ops, CircuitOp("CX", [q, q+1]))164        push!(ops, CircuitOp("H", [q]))165        push!(ops, CircuitOp("MEASURE", [q]))166    end167 168    return ops169end170 171end # module LatticeSurgery172