Predefined useful states.

Signed-off-by: Stefan Krastanov <stefan@krastanov.org>

src/QuantumClifford.jl

@@ -36,6 +36,7 @@ export @P_str, PauliOperator, ⊗, I, X, Y, Z, permute,
  apply_single_z!, apply_single_x!, apply_single_y!,
  random_invertible_gf2,
  random_pauli, random_stabilizer, random_destabilizer, random_clifford, random_singlequbitop,
+ bell, ghz,
  BadDataStructure
 
 # Predefined constants representing the permitted phases encoded
@@ -339,6 +340,10 @@ function apply!(s::AbstractStabilizer, p::AbstractCliffordOperator, indices; pha
  s
 end
 
+function ⊗(ops::AbstractStabilizer...)
+ foldl(⊗, ops[2:end], init=ops[1])
+end
+
 ##############################
 # Destabilizer formalism
 ##############################
@@ -1135,7 +1140,7 @@ function apply!(s::Stabilizer, p::PauliOperator, indices; phases::Bool=true)
  s
 end
 
-function tensor_pow(op::AbstractCliffordOperator,power::Integer)
+function tensor_pow(op,power::Integer) # TODO optimize (recursively) for large power
  ⊗(repeat([op],power)...)
 end
 
@@ -1900,6 +1905,7 @@ RecipesBase.@recipe function f(s::Stabilizer; xzcomponents=:split)
 end
 
 include("./randoms.jl")
+include("./useful_states.jl")
 include("./experimental/Experimental.jl")
 
 end #module

src/useful_states.jl

@@ -0,0 +1,98 @@
+"""Prepare one or more Bell pairs (with optional phases).
+
+```jldoctest
+julia> bell()
++ XX
++ ZZ
+
+julia> bell(2)
++ XX__
++ ZZ__
++ __XX
++ __ZZ
+
+julia> bell((true, false))
+- XX
++ ZZ
+
+julia> bell([true, false, true, true])
+- XX__
++ ZZ__
+- __XX
+- __ZZ
+```
+"""
+function bell end
+
+function bell()
+ copy(S"XX
+ ZZ")
+end
+
+function bell(n::Integer)
+ tensor_pow(bell(), n)
+end
+
+function bell(phase::Tuple{Bool, Bool})
+ s = bell()
+ s.phases[1] = phase[1] ? 0x2 : 0x0
+ s.phases[2] = phase[2] ? 0x2 : 0x0
+ s
+end
+
+function bell(phases::AbstractVector{Tuple{Bool, Bool}})
+ ⊗((bell(t) for t in phases)...)
+end
+
+function bell(phases::AbstractVector{Bool})
+ s = bell(length(phases)÷2)
+ for i in 1:length(s)
+ phases[i]
+ s.phases[i] = phases[i] ? 0x2 : 0x0
+ s[i], s.phases[i]
+ end
+ s
+end
+
+"""
+Prepare a GHZ state of n qubits.
+
+```jldoctest
+julia> ghz()
++ XXX
++ ZZ_
++ _ZZ
+
+julia> ghz(2)
++ XX
++ ZZ
+
+julia> ghz(4)
++ XXXX
++ ZZ__
++ _ZZ_
++ __ZZ
+```
+"""
+function ghz end
+
+function ghz()
+ copy(S"XXX
+ ZZI
+ IZZ")
+end
+
+function ghz(n::Integer)
+ s = zero(Stabilizer, n)
+ for i in 1:n
+ s[1,i] = (true,false)
+ end
+ for i in 2:n
+ s[i,i] = (false,true)
+ s[i,i-1] = (false,true)
+ end
+ s
+end
+
+# TODO document these explicitly
+# TODO cluster states, toric code, planar code, other codes from python libraries