misc cleanup and removing superficial changes

docs/src/circuit-simulation-manual.md

@@ -71,29 +71,9 @@ julia> quantumstate(stabmx)
 𝒮𝓉𝒶𝒷
 - XX
 - X_
-
-julia> stabmz = apply!(rng, copy(reg), sMZ(1, 1));
-
-julia> quantumstate(stabmz)
-𝒟ℯ𝓈𝓉𝒶𝒷
-- XX
-- ZZ
-𝒮𝓉𝒶𝒷
-+ Z_
-+ ZY
-
-julia> stabmy = apply!(rng, copy(reg), sMY(1, 1));
-
-julia> quantumstate(stabmy)
-𝒟ℯ𝓈𝓉𝒶𝒷
-- XX
-- YY
-𝒮𝓉𝒶𝒷
-+ Y_
-- YZ
 ```
 
-Projective measurements with automatic phase randomization, including [`projectY!`](@ref), [`projectZ!`](@ref) and [`projectrand!`](@ref) are available for the [`Register`](@ref) object.
+Projective measurements with automatic phase randomization, including [`projectXrand!`](@ref), [`projectYrand!`](@ref), [`projectZrand!`](@ref), and [`projectrand!`](@ref) are available for the [`Register`](@ref) object.
 
 ```jldoctest
 julia> rng = StableRNG(42); # hide
@@ -117,31 +97,11 @@ julia> quantumstate(px[1])
 𝒮𝓉𝒶𝒷
 + X_
 - _X
-
-julia> py = projectYrand!(rng, copy(reg), 1);
-
-julia> quantumstate(py[1])
-𝒟ℯ𝓈𝓉𝒶𝒷
-+ X_
-- _X
-𝒮𝓉𝒶𝒷
-+ Y_
-+ _Z
-
-julia> pz = projectZrand!(rng, copy(reg), 2);
-
-julia> quantumstate(pz[1])
-𝒟ℯ𝓈𝓉𝒶𝒷
-+ YZ
-- XX
-𝒮𝓉𝒶𝒷
-+ X_
-+ _Z
 ```
 
 # Pauli Frame
 
-[`PauliFrame`](@ref) is a wrapper for a "frame" tableau. Each row represents the Pauli operation differing 
+[`PauliFrame`](@ref) is a wrapper for a "frame" tableau. Each row represents the Pauli operation differing
 the frame from the reference, behaving uniquely under Clifford operations.
 
 ```jldoctest frame

docs/src/noisycircuits_mc.md

@@ -40,7 +40,7 @@ n = NoiseOpAll(UnbiasedUncorrelatedNoise(epsilon))
 circuit = [n,g1,g2,m,v]
 ```
 
-And we can run a Monte Carlo simulation on the above circuit with [`mctrajectories`](@ref).
+And we can run a Monte Carlo simulation of that circuit with [`mctrajectories`](@ref).
 
 ```@example 1
 mctrajectories(initial_state, circuit, trajectories=500)

src/classical_register.jl

@@ -49,13 +49,8 @@ struct Register{T<:Tableau} <: AbstractQCState # TODO simplify type parameters (
     Register(s::MixedDestabilizer{T}, bits) where {T} = new{T}(s,bits)
 end
 
-"""$(TYPEDSIGNATURES)"""
 Register(s,bits) = Register(MixedDestabilizer(s), bits)
-
-"""$(TYPEDSIGNATURES)"""
 Register(s) = Register(s, Bool[])
-
-"""$(TYPEDSIGNATURES)"""
 Register(s::MixedDestabilizer,nbits::Int) = Register(s, falses(nbits))
 
 Base.copy(r::Register) = Register(copy(r.stab),copy(r.bits))
@@ -80,46 +75,34 @@ quantumstate(r::Register) = r.stab
 
 tab(r::Register) = tab(quantumstate(r))
 
-"""$(TYPEDSIGNATURES)"""
 tensor(regs::Register...) = Register(tensor((quantumstate(r) for r in regs)...), [bit for r in regs for bit in r.bits])
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(r::Register, op, args...; kwargs...)
     apply!(quantumstate(r), op, args...; kwargs...)
     r
 end
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(rng::AbstractRNG, r::Register, m::sMX)
     _, res = projectXrand!(rng, r,m.qubit)
     m.bit!=0 && (bitview(r)[m.bit] = !iszero(res))
     r
 end
-
-"""$(TYPEDSIGNATURES)"""
 apply!(r::Register, m::sMX) = apply!(GLOBAL_RNG, r, m)
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(rng::AbstractRNG, r::Register, m::sMY)
     _, res = projectYrand!(rng, r,m.qubit)
     m.bit!=0 && (bitview(r)[m.bit] = !iszero(res))
     r
 end
-
-"""$(TYPEDSIGNATURES)"""
 apply!(r::Register, m::sMY) = apply!(GLOBAL_RNG, r, m)
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(rng::AbstractRNG, r::Register, m::sMZ)
     _, res = projectZrand!(rng, r,m.qubit)
     m.bit!=0 && (bitview(r)[m.bit] = !iszero(res))
     r
 end
-
-"""$(TYPEDSIGNATURES)"""
 apply!(r::Register, m::sMZ) = apply!(GLOBAL_RNG, r, m)
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(r::Register, m::sMRX) # TODO sMRY
     _, anticom, res = projectX!(quantumstate(r),m.qubit)
     mres = if isnothing(res)
@@ -135,8 +118,6 @@ function apply!(r::Register, m::sMRX) # TODO sMRY
     end
     r
 end
-
-"""$(TYPEDSIGNATURES)"""
 function apply!(r::Register, m::sMRZ) # TODO sMRY
     _, anticom, res = projectZ!(quantumstate(r),m.qubit)
     mres = if isnothing(res)
@@ -152,8 +133,6 @@ function apply!(r::Register, m::sMRZ) # TODO sMRY
     end
     r
 end
-
-"""$(TYPEDSIGNATURES)"""
 function apply!(r::Register, m::PauliMeasurement{A,B}) where {A,B}
     _, res = projectrand!(r,m.pauli)
     m.bit!=0 && (bitview(r)[m.bit] = !iszero(res))
@@ -190,26 +169,6 @@ julia> quantumstate(reg)
 𝒮𝓉𝒶𝒷
 + X_
 - _X
-
-julia> projectYrand!(rng, reg, 1);
-
-julia> quantumstate(reg)
-𝒟ℯ𝓈𝓉𝒶𝒷
-+ X_
-+ _Z
-𝒮𝓉𝒶𝒷
-+ Y_
-- _X
-
-julia> projectZrand!(rng, reg, 2);
-
-julia> quantumstate(reg)
-𝒟ℯ𝓈𝓉𝒶𝒷
-+ X_
-- _X
-𝒮𝓉𝒶𝒷
-+ Y_
-+ _Z
 ```
 
 See also: [`projectY!`](@ref), [`projectZ!`](@ref), [`projectrand!`](@ref), [`sMY`](@ref), [`sMZ`](@ref),
@@ -220,38 +179,28 @@ function projectXrand!(rng::AbstractRNG, r::Register, m)
     _, res = projectXrand!(rng, q,m)
     r, res
 end
-
-"""$(TYPEDSIGNATURES)"""
 projectXrand!(r::Register, m) = projectXrand!(GLOBAL_RNG, r, m)
 
-"""$(TYPEDSIGNATURES)"""
 function projectYrand!(rng::AbstractRNG, r::Register, m)
     q = quantumstate(r)
     _, res = projectYrand!(rng, q,m)
     r, res
 end
-
-"""$(TYPEDSIGNATURES)"""
 projectYrand!(r::Register, m) = projectYrand!(GLOBAL_RNG, r, m)
 
-"""$(TYPEDSIGNATURES)"""
 function projectZrand!(rng::AbstractRNG, r::Register, m)
     q = quantumstate(r)
     _, res = projectZrand!(rng, q,m)
     r, res
 end
-
-"""$(TYPEDSIGNATURES)"""
 projectZrand!(r::Register, m) = projectZrand!(GLOBAL_RNG, r, m)
 
-"""$(TYPEDSIGNATURES)"""
 function projectrand!(r::Register, m)
     q = quantumstate(r)
     _, res = projectrand!(q,m)
     r, res
 end
 
-"""$(TYPEDSIGNATURES)"""
 function traceout!(r::Register, arg)
     q = quantumstate(r)
     traceout!(q,arg)
@@ -262,13 +211,11 @@ end
 # petrajectories, applynoise_branches
 ##
 
-"""$(TYPEDSIGNATURES)"""
 function applynoise_branches(state::Register, noise, indices; max_order=1)
     [(Register(newstate,copy(state.bits)), prob, order)
      for (newstate, prob, order) in applynoise_branches(quantumstate(state), noise, indices; max_order=max_order)]
 end
 
-"""$(TYPEDSIGNATURES)"""
 function applybranches(s::Register, op::PauliMeasurement; max_order=1) # TODO this is almost the same as `applybranches(s::Register, op::AbstractMeasurement; max_order=1)` defined below
     stab = s.stab
     stab, anticom, r = project!(stab, op.pauli)
@@ -289,7 +236,6 @@ function applybranches(s::Register, op::PauliMeasurement; max_order=1) # TODO th
     new_branches
 end
 
-"""$(TYPEDSIGNATURES)"""
 function applybranches(s::Register, op::AbstractMeasurement; max_order=1)
     stab = s.stab
     stab, anticom, r = project!(stab, op)

src/pauli_frames.jl

@@ -54,16 +54,13 @@ function initZ!(rng::AbstractRNG, frame::PauliFrame)
     return frame
 end
 
-"""$(TYPEDSIGNATURES)"""
 initZ!(frame::PauliFrame) = initZ!(GLOBAL_RNG, frame)
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(f::PauliFrame, op::AbstractCliffordOperator)
     _apply!(f.frame, op; phases=Val(false))
     return f
 end
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(frame::PauliFrame, xor::ClassicalXOR)
     for f in eachindex(frame)
         value = frame.measurements[f,xor.bits[1]]
@@ -75,20 +72,17 @@ function apply!(frame::PauliFrame, xor::ClassicalXOR)
     return frame
 end
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(frame::PauliFrame, op::sMX) # TODO implement a faster direct version
     op.bit == 0 && return frame
     apply!(frame, sHadamard(op.qubit))
     apply!(frame, sMZ(op.qubit, op.bit))
 end
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(frame::PauliFrame, op::sMRX) # TODO implement a faster direct version
     apply!(frame, sHadamard(op.qubit))
     apply!(frame, sMRZ(op.qubit, op.bit))
 end
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(frame::PauliFrame, op::sMZ) # TODO sMY, and faster sMX
     op.bit == 0 && return frame
     i = op.qubit
@@ -107,7 +101,6 @@ function apply!(frame::PauliFrame, op::sMZ) # TODO sMY, and faster sMX
     return frame
 end
 
-"""$(TYPEDSIGNATURES)"""
 function apply!(frame::PauliFrame, op::sMRZ) # TODO sMRY, and faster sMRX
     i = op.qubit
     xzs = frame.frame.tab.xzs
@@ -131,7 +124,6 @@ function apply!(frame::PauliFrame, op::sMRZ) # TODO sMRY, and faster sMRX
     return frame
 end
 
-"""$(TYPEDSIGNATURES)"""
 function applynoise!(frame::PauliFrame,noise::UnbiasedUncorrelatedNoise,i::Int)
     p = noise.p
     T = eltype(frame.frame.tab.xzs)
@@ -156,7 +148,6 @@ function applynoise!(frame::PauliFrame,noise::UnbiasedUncorrelatedNoise,i::Int)
     return frame
 end
 
-"""$(TYPEDSIGNATURES)"""
 function applynoise!(frame::PauliFrame,noise::PauliNoise,i::Int)
     T = eltype(frame.frame.tab.xzs)