Tensor network backend
Simulating quantum circuits using tensor networks has been studied in the literature[Markov2008][Pan2022]. The YaoToEinsum
package provides a convenient way to convert Yao circuits to tensor networks, which can be used for further analysis and optimization.
Tutorial
The main function is
yao2einsum(circuit; initial_state=Dict(), final_state=Dict(), optimizer=TreeSA())
which transforms a Yao
circuit to a tensor network that generalizes the hyper-graph (einsum notation). The return value is a TensorNetwork
object.
initial_state
andfinal_state
are for specifying the initial state and final state. Left the qubits unspecified if you want to keep them as the open indices.optimizer
is for specifying the contraction order optimizing algorithm of the tensor network. The default value is theTreeSA()
algorithm that developed in [Kalachev2021][Liu2023]. Please check the README of OMEinsumEinsumContractors.jl for more information.
In the following example, we show how to convert a quantum Fourier transform circuit to a tensor network and contract it to
- Get the matrix representation of the circuit.
- Get the probability of measuring the zero state after applying the circuit on the zero state.
julia> import Yao
julia> using Yao.EasyBuild: qft_circuit
julia> n = 10;
julia> circuit = qft_circuit(n); # build a quantum Fourier transform circuit
julia> network = Yao.yao2einsum(circuit) # convert this circuit to tensor network
TensorNetwork Time complexity: 2^20.052833352562715 Space complexity: 2^20.0 Read-write complexity: 2^20.104081687003603
julia> reshape(Yao.contract(network), 1<<n, 1<<n) ≈ Yao.mat(circuit)
true
julia> network = Yao.yao2einsum(circuit; # convert circuit sandwiched by zero states initial_state=Dict([i=>0 for i=1:n]), final_state=Dict([i=>0 for i=1:n]), optimizer=Yao.YaoToEinsum.TreeSA(; nslices=3)) # slicing technique
TensorNetwork Time complexity: 2^12.25029841790633 Space complexity: 2^5.0 Read-write complexity: 2^13.068778277985412
julia> Yao.contract(network)[] ≈ Yao.zero_state(n)' * (Yao.zero_state(n) |> circuit)
true
API
YaoToEinsum.yao2einsum
— Functionyao2einsum(circuit; initial_state=Dict(), final_state=Dict(), optimizer=TreeSA())
yao2einsum(circuit, initial_state::Dict, final_state::Dict, optimizer)
Transform a Yao circuit
to a generalized tensor network (einsum) notation. The return value is a TensorNetwork
instance.
Arguments
circuit
is a Yao block as the input.initial_state
andfinal_state
are dictionaries to specify the initial states and final states (taking conjugate).- In the first interface, a state is specified as an integer, e.g.
Dict(1=>1, 2=>1, 3=>0, 4=>1)
specifies a product state|1⟩⊗|1⟩⊗|0⟩⊗|1⟩
. - In the second interface, a state is specified as an
ArrayReg
, e.g.Dict(1=>rand_state(1), 2=>rand_state(1))
.
- In the first interface, a state is specified as an integer, e.g.
If any qubit in initial state or final state is not specified, it will be treated as a free leg in the tensor network.
optimizer
is the optimizer used to optimize the tensor network. The default isTreeSA()
.
Please check OMEinsumContractors.jl for more information.
julia> using Yao
julia> c = chain(3, put(3, 2=>X), put(3, 1=>Y), control(3, 1, 3=>Y))
nqubits: 3
chain
├─ put on (2)
│ └─ X
├─ put on (1)
│ └─ Y
└─ control(1)
└─ (3,) Y
julia> yao2einsum(c; initial_state=Dict(1=>0, 2=>1), final_state=Dict(1=>ArrayReg([0.6, 0.8im]), 2=>1))
TensorNetwork
Time complexity: 2^4.700439718141093
Space complexity: 2^2.0
Read-write complexity: 2^6.0
YaoToEinsum.TensorNetwork
— TypeTensorNetwork
A (generalized) tensor network representation of a quantum circuit.
Fields
code::AbstractEinsum
: The einsum code.tensors::Vector
: The tensors in the network.
OMEinsumContractionOrders.optimize_code
— Functionoptimize_code(c::TensorNetwork, optimizer=TreeSA())
Optimize the code of the tensor network.
Arguments
c::TensorNetwork
: The tensor network.optimizer::Optimizer
: The optimizer to use, default isTreeSA()
. Please check OMEinsumContractors.jl for more information.
OMEinsumContractionOrders.contraction_complexity
— Functioncontraction_complexity(c::TensorNetwork)
Return the contraction complexity of the tensor network.
YaoToEinsum.contract
— Functioncontract(c::TensorNetwork)
Contract the tensor network, and return the result tensor.
References
- Pan2022Pan, Feng, and Pan Zhang. "Simulation of quantum circuits using the big-batch tensor network method." Physical Review Letters 128.3 (2022): 030501.
- Kalachev2021Kalachev, Gleb, Pavel Panteleev, and Man-Hong Yung. "Recursive multi-tensor contraction for xeb verification of quantum circuits." arXiv preprint arXiv:2108.05665 (2021).
- Markov2008Markov, Igor L., and Yaoyun Shi. "Simulating quantum computation by contracting tensor networks." SIAM Journal on Computing 38.3 (2008): 963-981.
- Liu2023Liu, Jin-Guo, et al. "Computing solution space properties of combinatorial optimization problems via generic tensor networks." SIAM Journal on Scientific Computing 45.3 (2023): A1239-A1270.