Measurements

What is measured

measure(state, measurement) returns the value of one measurement, and measure(state, measurements; time, values...) those of a list, in their order, as pairs name => value, as v[i] and v[[i]] give an element and a vector. A measurement is an operator, a measurement of the library, a symbol, or a function of the context, each possibly named, and a list of them is a vector or a Measure, which keeps what it prepares for the next call, as a phase keeps its lists while it runs. The examples below use a four qubit state

using TensorMixedStates, .Qubits

mystate = State{Mixed}(System(4, Qubit()), ["+", "Up", "+", "Dn"])

With an operator placed on sites, we get its expectation value

measure(mystate, X(1)X(3)Z(4))

-1.0

With an operator of one site, its expectation value on each site

measure(mystate, X)

4-element Vector{Float64}:
 1.0
 0.0
 1.0
 0.0

With a pair of operators of one site, the matrix of their correlations

measure(mystate, (X, Y))

4×4 Matrix{ComplexF64}:
 0.0+0.0im  0.0+0.0im  0.0+0.0im  0.0+0.0im
 0.0+0.0im  0.0+1.0im  0.0+0.0im  0.0+0.0im
 0.0+0.0im  0.0+0.0im  0.0+0.0im  0.0+0.0im
 0.0+0.0im  0.0+0.0im  0.0+0.0im  0.0-1.0im

The library measures the state as a whole:

measurement	value
`Trace`	the trace of the state, a complex number
`TraceDeviation`	`1 - trace`, which numerical errors tend to move, a complex number
`Purity`	$\mathrm{tr}(\rho^\dagger\rho)/(\mathrm{tr}\,\rho)^2$, $\mathrm{tr}(\rho^2)$ for a density matrix of trace one, 1 on a pure state
`Norm`	the norm of the state
`Hermiticity`	1 for a Hermitian density matrix, down to 0 for an anti-Hermitian one
`HermiticityDeviation`	`1 - hermiticity`, the squared norm of the anti-Hermitian part relative to that of the whole
`Renyi2`	the Rényi entropy of order 2 of the state
`Renyi2(positions)`	the Rényi entropy of order 2 of the sites at `positions`, `1:k` for the first `k`
`MutualInfoRenyi2(positions)`	the Rényi-2 mutual information between the sites at `positions` and the others
`VonNeumannEntropy(positions)`	the von Neumann entropy of the sites at `positions`, from their reduced density matrix
`ReducedDensityMatrix(positions)`	the density matrix of the sites at `positions`, a complex matrix, see `reduced_density_matrix`
`LogNegativity(positions_a, positions_b)`	the logarithmic negativity between the sites of `positions_a` and those of `positions_b`
`EntanglementEntropy(cut)`	the entanglement entropy across the cut between sites `cut` and `cut+1`, the operator space entanglement entropy (OSEE) on a mixed representation
`EntanglementSpectrum(cut, n)`	the first `n` values of the spectrum the entropy is computed from, padded with zeros, see `entanglement_spectrum`
`Fidelity(ref)`	the fidelity with the reference state `ref`, or with the state of that name in a simulation, `Fidelity(:ground)`
`Overlap(ref)`	the inner product with the reference state `ref`, a complex number, or with a state named in a simulation
`Overlap(ref, op)`	the matrix element $\langle ref \vert op \vert state \rangle$ of two pure states, or its vector for an operator of one site on every site, the correlations at two times of a reference evolved with the state
`Variance(op)`	the variance of the operator `op`
`MaxLinkdim`	the maximum bond dimension of the state
`MemoryUsage`	the memory the state occupies in bytes, the caches of the measurements included

measure(mystate, [Trace, Purity, EntanglementEntropy(2)])

3-element Vector{Pair{String, Any}}:
                  "Trace" => 0.9999999999999996 + 0.0im
                 "Purity" => 1.0
 "EntanglementEntropy(2)" => 0.0

Anything else is measured by a function of the context c, named: c.state is the state, c.time the time given to measure, and the other values given to it are read as c.energy, for instance. A symbol stands for the value of that name:

measure(mystate, ["half_trace" => c -> trace(c.state) / 2, "cos" => c -> cos(2c.time), :energy];
        time = 0.3, energy = -1.5)

3-element Vector{Pair{String, Any}}:
 "half_trace" => 0.4999999999999998
        "cos" => 0.8253356149096783
     "energy" => -1.5

A list given after the name of a state, :φ => [Z, (X, X), Purity], measures the state of that name with all of the above, its measurements named after it, φ.Z, φ.(X, X) and φ.Purity, as their columns are:

measure(mystate, [Z(1), :reference => [Z(1), Purity]];
        reference = State{Pure}(System(4, Qubit()), "Dn"))

3-element Vector{Pair{String, Any}}:
             "Z(1)" => 0.0
   "reference.Z(1)" => -1.0
 "reference.Purity" => 1.0

In a simulation, the values are those its phases provide: :step the number of steps the phase has done, the sweeps of a search, :energy the energy of each sweep of GroundState, :residual for SteadyState the eigenvalue of $L^\dagger L$, zero for a steady state, and :beta and :log_trace the inverse temperature and the logarithm of the trace of Thermalize, see thermalize. A state named in a simulation, by CopyState for instance, is a value as well, and Update provides the values it declares. A measurement reading a value that no phase provides is refused when the simulation is written, see SimData.

A function of the context may return a Check, which compares a value with a reference:

measure(mystate, "check" => c -> Check(expect(c.state, X(1)), 1.0; tol = 1e-8))

(value = 1.0, reference = 1.0, difference = 0.0)

The value is then the value, the reference and their distance, and a distance beyond tol is an error, or only a warning with warn = true. Without tol, the three are recorded and nothing is refused.

Real and complex values

The value of an operator is real when the operator is Hermitian, which is tested numerically, and complex otherwise, whatever the state, so that the columns of a file do not change during a run. A pair (A, B) is Hermitian when A and B are, commute on a site and are not both fermionic: (X, Y), whose diagonal is $\langle XY \rangle = i \langle Z \rangle$, is complex. The imaginary part of the value of a Hermitian operator is dropped, with a warning when it is more than rounding, which a density matrix that lost its hermiticity gives; a simulation gathers these warnings into one at the end of each phase. Trace, TraceDeviation, Overlap and ReducedDensityMatrix are complex, the other measurements of the library real, and a function of the context gives what it returns.

expect, expect1 and expect2 give their values by the same rule. With complex = true, they give the complex numbers computed, imaginary parts included, which a list of measurements gets through a function: "x" => c -> expect(c.state, X(1); complex = true).

Two copies of the state

The quantities quadratic in the density matrix are inner products of the density matrix with itself through a channel or a generator, see inner, each a contraction as expect makes on a density matrix:

quantity	written as
$\mathrm{tr}\,\rho^2$	`inner(ρ, ρ)`
$\mathrm{tr}(\rho K \rho K^\dagger)$	`inner(ρ, Gate(K), ρ)`
$\mathrm{tr}(A \rho^2)$, `A` Hermitian	`inner(ρ, Evolver(A / 2), ρ)`

Divided by $\mathrm{tr}\,\rho^2$, the second is, for K a product of operators on two sites, a Rényi-2 correlator of the mixed state, and the third the mean value of A in $\rho^2 / \mathrm{tr}\,\rho^2$, which virtual distillation estimates; for an A that is not Hermitian, the third gives that of its Hermitian part. A list of measurements takes them through a function:

"C2" => c -> inner(c.state, Gate(X(1) * X(5)), c.state) / inner(c.state, c.state)

Reference

TensorMixedStates.measure — Function

measure(state, measurement; time, values...)
measure(state, measurements; time, values...)

the value of one measurement on state, or those of a list of them, a vector, a Measure or :φ => list, as a vector of pairs name => value in their order, as v[i] and v[[i]] give an element and a vector. An operator placed on sites gives its expectation value, an operator of one site a vector indexed by site and a pair a matrix, as expect1 and expect2 give them, made real when the operator, or each product of the pair, is Hermitian, with a warning when the imaginary part dropped is beyond rounding, and complex otherwise; any other value is given as it is computed, a Check as (value, reference, difference). time and the values are what a measurement written as a function reads as c.time and c.energy, and what a symbol stands for, a symbol of the list without a value being refused before anything is measured. A Measure keeps its preparation, which a list given as it is makes anew at each call.

Examples

measure(state, Purity)
measure(state, [X, (X, Y), Z(1) * Z(2), Purity])
measure(state, ["E" => H, "cos" => c -> cos(2c.time), :energy]; time = 1.5, energy = -3.2)

Measurements

What is measured

Real and complex values

Two copies of the state

Reference

Output