migrate to ZXCircuit

ChenZhao44 · ChenZhao44 · commit da99f021bd35 · 2025-10-26T20:33:59.000-04:00
diff --git a/src/ZX/ZX.jl b/src/ZX/ZX.jl
@@ -31,7 +31,7 @@ export FusionRule, XToZRule,
 
 export rewrite!, simplify!
 
-export convert_to_chain, convert_to_zxd, convert_to_zxwd
+export convert_to_chain, convert_to_circuit, convert_to_zxd, convert_to_zxwd
 export clifford_simplification, full_reduction, circuit_extraction, phase_teleportation
 export plot
 export concat!, dagger, contains_only_bare_wires, verify_equality
diff --git a/src/ZX/circuit_extraction.jl b/src/ZX/circuit_extraction.jl
@@ -8,7 +8,7 @@ Extract a quantum circuit from a general ZX-graph even without a gflow.
 This function can handle ZX-graphs that don't have a generalised flow (gflow),
 and will introduce post-selection operators as needed.
 
-Returns a `ZXDiagram` representing the extracted circuit.
+Returns a `ZXCircuit` representing the extracted circuit.
 """
 function ancilla_extraction(zxg::Union{ZXGraph, ZXCircuit})
     nzxg = copy(zxg)
@@ -35,7 +35,7 @@ function ancilla_extraction(zxg::Union{ZXGraph, ZXCircuit})
     end
 
     frontiers = copy(outs)
-    circ = ZXDiagram(nbits)
+    circ = ZXCircuit(nbits)
     unextracts = Set(spiders(nzxg))
     qubit_map = Dict{Int, Int}()
     for i in eachindex(ins)
diff --git a/src/ZX/equality.jl b/src/ZX/equality.jl
@@ -18,6 +18,28 @@ function verify_equality(zxd_1::ZXDiagram, zxd_2::ZXDiagram)
     return contains_only_bare_wires(m_simple)
 end
 
+"""
+    $(TYPEDSIGNATURES)
+
+Check the equivalence of two different ZX-circuits.
+
+This function concatenates the first circuit with the dagger of the second,
+then performs full reduction. If the result contains only bare wires, the
+circuits are equivalent.
+
+Returns `true` if the circuits are equivalent, `false` otherwise.
+"""
+function verify_equality(circ_1::ZXCircuit, circ_2::ZXCircuit)
+    merged_circuit = copy(circ_1)
+    merged_circuit = concat!(merged_circuit, dagger(circ_2))
+    m_simple = full_reduction(merged_circuit)
+    return contains_only_bare_wires(m_simple)
+end
+
+# Mixed type comparisons
+verify_equality(c1::ZXCircuit, c2::ZXDiagram) = verify_equality(c1, ZXCircuit(c2))
+verify_equality(c1::ZXDiagram, c2::ZXCircuit) = verify_equality(ZXCircuit(c1), c2)
+
 function contains_only_bare_wires(zxd::Union{ZXDiagram, ZXGraph})
     return all(is_in_or_out_spider(st[2]) for st in zxd.st)
 end
diff --git a/src/ZX/implementations/zx_circuit/circuit_ops.jl b/src/ZX/implementations/zx_circuit/circuit_ops.jl
@@ -1,17 +1,118 @@
 # Circuit Interface Implementation for ZXCircuit
 
-nqubits(circ::ZXCircuit) = max(length(circ.inputs), length(circ.outputs))
+nqubits(circ::ZXCircuit) = circ.layout.nbits
 get_inputs(circ::ZXCircuit) = circ.inputs
 get_outputs(circ::ZXCircuit) = circ.outputs
 
-# Gate operations - these will be defined in gate_ops.jl for ZXDiagram
-# but ZXCircuit doesn't implement them directly yet
-# For now, we define stubs that throw NotImplementedError
+# Gate operations for ZXCircuit
+# These operate on the underlying ZXGraph
 
-function push_gate!(circ::ZXCircuit, args...)
-    error("push_gate! not yet implemented for ZXCircuit. Use ZXDiagram for gate operations.")
+function push_gate!(circ::ZXCircuit{T, P}, ::Val{:Z}, loc::T, phase=zero(P); autoconvert::Bool=true) where {T, P}
+    @inbounds out_id = get_outputs(circ)[loc]
+    @inbounds bound_id = neighbors(circ, out_id)[1]
+    rphase = autoconvert ? safe_convert(P, phase) : phase
+    insert_spider!(circ, bound_id, out_id, SpiderType.Z, rphase)
+    return circ
 end
 
-function pushfirst_gate!(circ::ZXCircuit, args...)
-    error("pushfirst_gate! not yet implemented for ZXCircuit. Use ZXDiagram for gate operations.")
+function push_gate!(circ::ZXCircuit{T, P}, ::Val{:X}, loc::T, phase=zero(P); autoconvert::Bool=true) where {T, P}
+    @inbounds out_id = get_outputs(circ)[loc]
+    @inbounds bound_id = neighbors(circ, out_id)[1]
+    rphase = autoconvert ? safe_convert(P, phase) : phase
+    insert_spider!(circ, bound_id, out_id, SpiderType.X, rphase)
+    return circ
+end
+
+function push_gate!(circ::ZXCircuit{T, P}, ::Val{:H}, loc::T) where {T, P}
+    @inbounds out_id = get_outputs(circ)[loc]
+    @inbounds bound_id = neighbors(circ, out_id)[1]
+    insert_spider!(circ, bound_id, out_id, SpiderType.H)
+    return circ
+end
+
+function push_gate!(circ::ZXCircuit{T, P}, ::Val{:SWAP}, locs::Vector{T}) where {T, P}
+    q1, q2 = locs
+    push_gate!(circ, Val{:Z}(), q1)
+    push_gate!(circ, Val{:Z}(), q2)
+    push_gate!(circ, Val{:Z}(), q1)
+    push_gate!(circ, Val{:Z}(), q2)
+    v1, v2, bound_id1, bound_id2 = (sort!(spiders(circ)))[(end - 3):end]
+    rem_edge!(circ, v1, bound_id1)
+    rem_edge!(circ, v2, bound_id2)
+    add_edge!(circ, v1, bound_id2)
+    add_edge!(circ, v2, bound_id1)
+    return circ
+end
+
+function push_gate!(circ::ZXCircuit{T, P}, ::Val{:CNOT}, loc::T, ctrl::T) where {T, P}
+    push_gate!(circ, Val{:Z}(), ctrl)
+    push_gate!(circ, Val{:X}(), loc)
+    @inbounds v1, v2 = (sort!(spiders(circ)))[(end - 1):end]
+    add_edge!(circ, v1, v2)
+    add_power!(circ, 1)
+    return circ
+end
+
+function push_gate!(circ::ZXCircuit{T, P}, ::Val{:CZ}, loc::T, ctrl::T) where {T, P}
+    push_gate!(circ, Val{:Z}(), ctrl)
+    push_gate!(circ, Val{:Z}(), loc)
+    @inbounds v1, v2 = (sort!(spiders(circ)))[(end - 1):end]
+    add_edge!(circ, v1, v2)
+    insert_spider!(circ, v1, v2, SpiderType.H)
+    add_power!(circ, 1)
+    return circ
+end
+
+function pushfirst_gate!(circ::ZXCircuit{T, P}, ::Val{:Z}, loc::T, phase::P=zero(P)) where {T, P}
+    @inbounds in_id = get_inputs(circ)[loc]
+    @inbounds bound_id = neighbors(circ, in_id)[1]
+    insert_spider!(circ, in_id, bound_id, SpiderType.Z, phase)
+    return circ
+end
+
+function pushfirst_gate!(circ::ZXCircuit{T, P}, ::Val{:X}, loc::T, phase::P=zero(P)) where {T, P}
+    @inbounds in_id = get_inputs(circ)[loc]
+    @inbounds bound_id = neighbors(circ, in_id)[1]
+    insert_spider!(circ, in_id, bound_id, SpiderType.X, phase)
+    return circ
+end
+
+function pushfirst_gate!(circ::ZXCircuit{T, P}, ::Val{:H}, loc::T) where {T, P}
+    @inbounds in_id = get_inputs(circ)[loc]
+    @inbounds bound_id = neighbors(circ, in_id)[1]
+    insert_spider!(circ, in_id, bound_id, SpiderType.H)
+    return circ
+end
+
+function pushfirst_gate!(circ::ZXCircuit{T, P}, ::Val{:SWAP}, locs::Vector{T}) where {T, P}
+    q1, q2 = locs
+    pushfirst_gate!(circ, Val{:Z}(), q1)
+    pushfirst_gate!(circ, Val{:Z}(), q2)
+    pushfirst_gate!(circ, Val{:Z}(), q1)
+    pushfirst_gate!(circ, Val{:Z}(), q2)
+    v1, v2, bound_id1, bound_id2 = (sort!(spiders(circ)))[1:4]
+    rem_edge!(circ, v1, bound_id1)
+    rem_edge!(circ, v2, bound_id2)
+    add_edge!(circ, v1, bound_id2)
+    add_edge!(circ, v2, bound_id1)
+    return circ
+end
+
+function pushfirst_gate!(circ::ZXCircuit{T, P}, ::Val{:CNOT}, loc::T, ctrl::T) where {T, P}
+    pushfirst_gate!(circ, Val{:X}(), loc)
+    pushfirst_gate!(circ, Val{:Z}(), ctrl)
+    @inbounds v1, v2 = (sort!(spiders(circ)))[1:2]
+    add_edge!(circ, v1, v2)
+    add_power!(circ, 1)
+    return circ
+end
+
+function pushfirst_gate!(circ::ZXCircuit{T, P}, ::Val{:CZ}, loc::T, ctrl::T) where {T, P}
+    pushfirst_gate!(circ, Val{:Z}(), loc)
+    pushfirst_gate!(circ, Val{:Z}(), ctrl)
+    @inbounds v1, v2 = (sort!(spiders(circ)))[1:2]
+    add_edge!(circ, v1, v2)
+    insert_spider!(circ, v1, v2, SpiderType.H)
+    add_power!(circ, 1)
+    return circ
 end
diff --git a/src/ZX/implementations/zx_circuit/type.jl b/src/ZX/implementations/zx_circuit/type.jl
@@ -71,6 +71,58 @@ function ZXCircuit(zxg::ZXGraph{T, P}) where {T, P}
     return ZXCircuit(zxg, inputs, outputs, layout, phase_ids, nothing)
 end
 
+"""
+    $(TYPEDSIGNATURES)
+
+Construct an empty ZX-circuit with `nbits` qubits.
+
+Each qubit is represented by a pair of In/Out spiders connected by a simple edge.
+This creates a minimal circuit structure ready for gate insertion.
+
+# Example
+```julia
+julia> circ = ZXCircuit(3)
+ZXCircuit with 3 inputs and 3 outputs...
+```
+"""
+function ZXCircuit(nbits::T) where {T <: Integer}
+    mg = Multigraph(2*nbits)
+    st = Dict{T, SpiderType.SType}()
+    ps = Dict{T, Phase}()
+    et = Dict{Tuple{T, T}, EdgeType.EType}()
+    spider_q = Dict{T, Rational{Int}}()
+    spider_col = Dict{T, Rational{Int}}()
+
+    inputs = Vector{T}()
+    outputs = Vector{T}()
+
+    for i in 1:nbits
+        in_id = T(2*i-1)
+        out_id = T(2*i)
+        add_edge!(mg, in_id, out_id)
+
+        st[in_id] = SpiderType.In
+        st[out_id] = SpiderType.Out
+        ps[in_id] = Phase(0//1)
+        ps[out_id] = Phase(0//1)
+        et[(in_id, out_id)] = EdgeType.SIM
+
+        spider_q[in_id] = i
+        spider_col[in_id] = 0
+        spider_q[out_id] = i
+        spider_col[out_id] = 1
+
+        push!(inputs, in_id)
+        push!(outputs, out_id)
+    end
+
+    layout = ZXLayout(nbits, spider_q, spider_col)
+    zxg = ZXGraph{T, Phase}(mg, ps, st, et, Scalar{Phase}())
+    phase_ids = Dict{T, Tuple{T, Int}}()
+
+    return ZXCircuit(zxg, inputs, outputs, layout, phase_ids)
+end
+
 function ZXDiagram(circ::ZXCircuit{T, P}) where {T, P}
     layout = circ.layout
     phase_ids = circ.phase_ids
diff --git a/src/ZX/implementations/zx_diagram/composition_ops.jl b/src/ZX/implementations/zx_diagram/composition_ops.jl
@@ -1,7 +1,7 @@
 # Circuit Composition Operations for ZXDiagram (Legacy)
 
 """
-    import_non_in_out!(d1::ZXDiagram{T,P}, d2::ZXDiagram{T,P}, v2tov1::Dict{T,T}) where {T,P}
+    $(TYPEDSIGNATURES)
 
 Add non input and output spiders of d2 to d1, modify d1. Record the mapping of vertex indices.
 """
@@ -30,7 +30,7 @@ function import_non_in_out!(
 end
 
 """
-    import_edges!(d1::ZXDiagram{T,P}, d2::ZXDiagram{T,P}, v2tov1::Dict{T,T}) where {T,P}
+    $(TYPEDSIGNATURES)
 
 Import edges of d2 to d1, modify d1
 """
@@ -42,7 +42,7 @@ function import_edges!(d1::ZXDiagram{T, P}, d2::ZXDiagram{T, P}, v2tov1::Dict{T,
 end
 
 """
-    concat!(zxd_1::ZXDiagram{T,P}, zxd_2::ZXDiagram{T,P})::ZXDiagram{T,P} where {T,P}
+    $(TYPEDSIGNATURES)
 
 Appends two diagrams, where the second diagram is inverted
 """
@@ -94,12 +94,12 @@ function stype_to_val(st)::Val
 end
 
 """
-    dagger(zxd::ZXDiagram{T,P})::ZXDiagram{T,P} where {T,P}
+    $(TYPEDSIGNATURES)
 
 Dagger of a ZXDiagram by swapping input and outputs and negating the values of the phases
 """
 function dagger(zxd::ZXDiagram{T, P})::ZXDiagram{T, P} where {T, P}
-    ps_i = Dict([k => -v for (k, v) in zxd.ps])
+    ps_i = Dict([k => -v for (k, v) in phases(zxd)])
     zxd_dg = ZXDiagram{T, P}(
         copy(zxd.mg),
         copy(zxd.st),
diff --git a/src/ZX/ir.jl b/src/ZX/ir.jl
@@ -1,4 +1,42 @@
-ZXDiagram(bir::BlockIR) = convert_to_zxd(bir)
+using DocStringExtensions
+
+"""
+    $(TYPEDSIGNATURES)
+
+Convert a BlockIR to a ZXCircuit.
+
+This function converts YaoHIR's BlockIR representation to a ZXCircuit by translating
+each gate operation to the corresponding ZX-diagram representation.
+
+Returns a `ZXCircuit` containing the circuit representation.
+
+See also: [`convert_to_zxd`](@ref)
+"""
+function convert_to_circuit(root::YaoHIR.BlockIR)
+    circ = ZXCircuit(root.nqubits)
+    circuit = canonicalize_single_location(root.circuit)
+    return gates_to_circ(circ, circuit, root)
+end
+
+"""
+    $(TYPEDSIGNATURES)
+
+Convert a BlockIR to a ZXDiagram.
+
+!!! warning "Deprecated"
+    `convert_to_zxd` is deprecated. Use [`convert_to_circuit`](@ref) instead.
+    This function internally converts to ZXCircuit and then wraps it in ZXDiagram.
+
+Returns a `ZXDiagram` for backward compatibility.
+"""
+function convert_to_zxd(root::YaoHIR.BlockIR)
+    Base.depwarn("convert_to_zxd is deprecated, use convert_to_circuit instead", :convert_to_zxd)
+    circ = convert_to_circuit(root)
+    return ZXDiagram(circ)
+end
+
+ZXDiagram(bir::BlockIR) = ZXDiagram(convert_to_circuit(bir))
+ZXCircuit(bir::BlockIR) = convert_to_circuit(bir)
 YaoHIR.Chain(zxd::ZXDiagram) = convert_to_chain(zxd)
 
 convert_to_gate(::Val{:X}, loc) = Gate(X, Locations(loc))
@@ -132,12 +170,6 @@ function gates_to_circ(circ, circuit, root)
     return circ
 end
 
-function convert_to_zxd(root::YaoHIR.BlockIR)
-    diagram = ZXDiagram(root.nqubits)
-    circuit = canonicalize_single_location(root.circuit)
-    return gates_to_circ(diagram, circuit, root)
-end
-
 function push_spider_to_chain!(qc, q, ps, st)
     if ps != 0
         if st == SpiderType.Z
diff --git a/test/ZX/zx_circuit_basic.jl b/test/ZX/zx_circuit_basic.jl
diff --git a/test/runtests.jl b/test/runtests.jl
