Blocks

Blocks are the basic building blocks of a quantum circuit in Yao. It simply means a quantum operator, thus, all the blocks have matrices in principal and one can get its matrix by mat. The basic blocks required to build an arbitrary quantum circuit is defined in the component package YaoBlocks.

Block Tree serves as an intermediate representation for Yao to analysis, optimize the circuit, then it will be lowered to instructions like for simulations, blocks will be lowered to instruct! calls.

The structure of blocks is the same with a small type system, it consists of two basic kinds of blocks: CompositeBlock (like composite types), and PrimitiveBlock (like primitive types). By combining these two kinds of blocks together, we'll be able to construct a quantum circuit and represent it in a tree data structure.

Primitive Blocks

Primitive blocks are subtypes of PrimitiveBlock, they are the leaf nodes in a block tree, thus primitive types do not have subtypes.

We provide the following primitive blocks:

YaoBlocks.GeneralMatrixBlock — Type.

GeneralMatrixBlock{M, N, T, MT} <: PrimitiveBlock{N, T}

General matrix gate wraps a matrix operator to quantum gates. This is the most general form of a quantum gate. M is the hilbert dimension (first dimension), N is the hilbert dimension (second dimension) of current quantum state. For most quantum gates, we have $M = N$.

YaoBlocks.Measure — Type.

Measure{N, K, OT} <: PrimitiveBlock{N, Bool}
Measure(n::Int; operator=ComputationalBasis(), locs=1:n, collapseto=nothing, remove=false)

Measure operator.

YaoBlocks.PhaseGate — Type.

PhiGate

Global phase gate.

YaoBlocks.PrimitiveBlock — Type.

PrimitiveBlock{N, T} <: AbstractBlock{N, T}

Abstract type that all primitive block will subtype from. A primitive block is a concrete block who can not be decomposed into other blocks. All composite block can be decomposed into several primitive blocks.

Note

subtype for primitive block with parameter should implement hash and == method to enable key value cache.

YaoBlocks.ReflectGate — Type.

ReflectGate{N, T, Tr} <: PrimitiveBlock{N, T}

Reflection operator to target state psi.

Definition

\[|ψ⟩ → 2 |s⟩⟨s| - 1\]

YaoBlocks.ReflectGate — Method.

ReflectGate(r::AbstractVector)

Create a ReflectGate with a quantum state vector v.

YaoBlocks.ReflectGate — Method.

ReflectGate(r::ArrayReg{1})

Create a ReflectGate with a quantum register r.

YaoBlocks.RotationGate — Type.

RotationGate{N, T, GT <: AbstractBlock{N, Complex{T}}} <: PrimitiveBlock{N, Complex{T}}

RotationGate, with GT both hermitian and isreflexive.

YaoBlocks.ShiftGate — Type.

ShiftGate <: PrimitiveBlock

Phase shift gate.

YaoBlocks.TimeEvolution — Type.

TimeEvolution{N, TT, GT} <: PrimitiveBlock{N, ComplexF64}

TimeEvolution, where GT is block type. input matrix should be hermitian.

!!!note: TimeEvolution contructor check hermicity of the input block by default, but sometimes it can be slow. Turn off the check manually by specifying optional parameter check_hermicity = false.

YaoBlocks.TimeEvolution — Method.

TimeEvolution(H, dt[; tol::Real=1e-7])

Create a TimeEvolution block with Hamiltonian H and time step dt. The TimeEvolution block will use Krylove based expv to calculate time propagation.

Optional keywords are tolerance tol (default is 1e-7) TimeEvolution block can also be used for imaginary time evolution if dt is complex.

Composite Blocks

Composite blocks are subtypes of CompositeBlock, they are the composition of blocks.

We provide the following composite blocks:

YaoBlocks.AbstractContainer — Type.

AbstractContainer{BT, N, T} <: CompositeBlock{N, T}

Abstract type for container block. Container blocks are blocks contain a single block. Container block should have a

YaoBlocks.CachedBlock — Type.

CachedBlock{ST, BT, N, T} <: TagBlock{BT, N, T}

A label type that tags an instance of type BT. It forwards every methods of the block it contains, except mat and apply!, it will cache the matrix form whenever the program has.

YaoBlocks.ChainBlock — Type.

ChainBlock{N, T} <: CompositeBlock{N, T}

ChainBlock is a basic construct tool to create user defined blocks horizontically. It is a Vector like composite type.

YaoBlocks.CompositeBlock — Type.

CompositeBlock{N, T} <: AbstractBlock{N, T}

Abstract supertype which composite blocks will inherit from. Composite blocks are blocks composited from other AbstractBlocks, thus it is a AbstractBlock as well.

YaoBlocks.Concentrator — Type.

Concentrator{N, T, BT <: AbstractBlock} <: AbstractContainer{BT, N, T}

concentrates serveral lines together in the circuit, and expose it to other blocks.

YaoBlocks.Daggered — Type.

Daggered{N, T, BT} <: TagBlock{N, T}

Wrapper block allowing to execute the inverse of a block of quantum circuit.

YaoBlocks.KronBlock — Type.

KronBlock{N, T, MT<:AbstractBlock} <: CompositeBlock{N, T}

composite block that combine blocks by kronecker product.

YaoBlocks.PauliString — Method.

PauliString(list::Vector)

Create a PauliString from a list of Pauli gates.

Example

julia> PauliString([X, Y, Z])
nqubits: 3, datatype: Complex{Float64}
PauliString
├─ X gate
├─ Y gate
└─ Z gate

YaoBlocks.PauliString — Method.

PauliString(xs::PauliGate...)

Create a PauliString from some Pauli gates.

Example

julia> PauliString(X, Y, Z)
nqubits: 3, datatype: Complex{Float64}
PauliString
├─ X gate
├─ Y gate
└─ Z gate

YaoBlocks.PutBlock — Type.

PutBlock <: AbstractContainer

Type for putting a block at given locations.

YaoBlocks.RepeatedBlock — Type.

RepeatedBlock <: AbstractContainer

Repeat the same block on given locations.

YaoBlocks.Roller — Type.

Roller{N, T, BT <: Tuple} <: CompositeBlock{N, T}

Roller block.

YaoBlocks.TagBlock — Type.

TagBlock{BT, N, T} <: AbstractContainer{BT, N, T}

TagBlock is a special kind of Container block, it forwards most of the methods but tag the block with some extra information.

APIs

Base.kron — Method.

kron(n, blocks::Pair{Int, <:AbstractBlock}...)

Return a KronBlock, with total number of qubits n and pairs of blocks.

Example

Use kron to construct a KronBlock, it will put an X gate on the 1st qubit, and a Y gate on the 3rd qubit.

julia> kron(4, 1=>X, 3=>Y)
nqubits: 4, datatype: Complex{Float64}
kron
├─ 1=>X gate
└─ 3=>Y gate

Base.kron — Method.

kron(blocks::AbstractBlock...)
kron(n, itr)

Return a KronBlock, with total number of qubits n, and blocks should use all the locations on n wires in quantum circuits.

Example

You can use kronecker product to composite small blocks to a large blocks.

julia> kron(X, Y, Z, Z)
nqubits: 4, datatype: Complex{Float64}
kron
├─ 1=>X gate
├─ 2=>Y gate
├─ 3=>Z gate
└─ 4=>Z gate

Base.kron — Method.

kron(blocks...) -> f(n)
kron(itr) -> f(n)

Return a lambda, which will take the total number of qubits as input.

Example

If you don't know the number of qubit yet, or you are just too lazy, it is fine.

julia> kron(put(1=>X) for _ in 1:2)
(n -> kron(n, (n  ->  put(n, 1 => X gate)), (n  ->  put(n, 1 => X gate))))

julia> kron(X for _ in 1:2)
nqubits: 2, datatype: Complex{Float64}
kron
├─ 1=>X gate
└─ 2=>X gate

julia> kron(1=>X, 3=>Y)
(n -> kron(n, 1 => X gate, 3 => Y gate))

Base.repeat — Method.

repeat(x::AbstractBlock, locs)

Lazy curried version of repeat.

Base.repeat — Method.

repeat(n, x::AbstractBlock[, locs]) -> RepeatedBlock{n}

Create a RepeatedBlock with total number of qubits n and the block to repeat on given location or on all the locations.

Example

This will create a repeat block which puts 4 X gates on each location.

julia> repeat(4, X)
nqubits: 4, datatype: Complex{Float64}
repeat on (1, 2, 3, 4)
└─ X gate

You can also specify the location

julia> repeat(4, X, (1, 2))
nqubits: 4, datatype: Complex{Float64}
repeat on (1, 2)
└─ X gate

But repeat won't copy the gate, thus, if it is a gate with parameter, e.g a phase(0.1), the parameter will change simultaneously.

julia> g = repeat(4, phase(0.1))
nqubits: 4, datatype: Complex{Float64}
repeat on (1, 2, 3, 4)
└─ phase(0.1)

julia> g.content
phase(0.1)

julia> g.content.theta = 0.2
0.2

julia> g
nqubits: 4, datatype: Complex{Float64}
repeat on (1, 2, 3, 4)
└─ phase(0.2)

YaoBlocks.Rx — Method.

Rx(theta)

Return a RotationGate on X axis.

YaoBlocks.Ry — Method.

Ry(theta)

Return a RotationGate on Y axis.

YaoBlocks.Rz — Method.

Rz(theta)

Return a RotationGate on Z axis.

YaoBlocks.apply! — Method.

apply!(register, block)

Apply a block (of quantum circuit) to a quantum register.