CircuitStateFn¶

class CircuitStateFn(primitive=None, coeff=1.0, is_measurement=False)[source]¶

A class for state functions and measurements which are defined by the action of a QuantumCircuit starting from |0⟩, and stored using Terra’s QuantumCircuit class.

Parameters

primitive (Union[Instruction, QuantumCircuit, None]) – The QuantumCircuit (or Instruction, which will be converted) which defines the behavior of the underlying function.
coeff (Union[int, float, complex, ParameterExpression]) – A coefficient multiplying the state function.
is_measurement (bool) – Whether the StateFn is a measurement operator.

Raises

TypeError – Unsupported primitive, or primitive has ClassicalRegisters.

Attributes

`CircuitStateFn.coeff`	A coefficient by which the state function is multiplied.
`CircuitStateFn.is_measurement`	Whether the StateFn object is a measurement Operator.
`CircuitStateFn.num_qubits`	The number of qubits over which the Operator is defined.
`CircuitStateFn.primitive`	The primitive which defines the behavior of the underlying State function.

Methods

`CircuitStateFn.__mul__`(other)	Overload `*` for Operator scalar multiplication.
`CircuitStateFn.add`(other)	Return Operator addition of self and other, overloaded by `+`.
`CircuitStateFn.adjoint`()	Return a new Operator equal to the Operator’s adjoint (conjugate transpose), overloaded by `~`.
`CircuitStateFn.assign_parameters`(param_dict)	Binds scalar values to any Terra `Parameters` in the coefficients or primitives of the Operator, or substitutes one `Parameter` for another.
`CircuitStateFn.bind_parameters`(param_dict)	Same as assign_parameters, but maintained for consistency with QuantumCircuit in Terra (which has both assign_parameters and bind_parameters).
`CircuitStateFn.compose`(other)	Composition (Linear algebra-style: A@B(x) = A(B(x))) is not well defined for states in the binary function model, but is well defined for measurements.
`CircuitStateFn.equals`(other)	Evaluate Equality between Operators, overloaded by `==`.
`CircuitStateFn.eval`([front])	Evaluate the Operator’s underlying function, either on a binary string or another Operator.
`CircuitStateFn.from_dict`(density_dict)	Construct the CircuitStateFn from a dict mapping strings to probability densities.
`CircuitStateFn.from_vector`(statevector)	Construct the CircuitStateFn from a vector representing the statevector.
`CircuitStateFn.mul`(scalar)	Returns the scalar multiplication of the Operator, overloaded by `*`, including support for Terra’s `Parameters`, which can be bound to values later (via `bind_parameters`).
`CircuitStateFn.neg`()	Return the Operator’s negation, effectively just multiplying by -1.0, overloaded by `-`.
`CircuitStateFn.permute`(permutation)	Permute the qubits of the circuit.
`CircuitStateFn.power`(exponent)	Compose with Self Multiple Times, undefined for StateFns.
`CircuitStateFn.primitive_strings`()	Return a set of strings describing the primitives contained in the Operator.
`CircuitStateFn.reduce`()	Try collapsing the Operator structure, usually after some type of conversion, e.g.
`CircuitStateFn.sample`([shots, massive, …])	Sample the state function as a normalized probability distribution.
`CircuitStateFn.tensor`(other)	Return tensor product between self and other, overloaded by `^`.
`CircuitStateFn.tensorpower`(other)	Return tensor product with self multiple times, overloaded by `^`.
`CircuitStateFn.to_circuit`([meas])	Return QuantumCircuit representing StateFn
`CircuitStateFn.to_circuit_op`()	Return `StateFnCircuit` corresponding to this StateFn.
`CircuitStateFn.to_density_matrix`([massive])	Return numpy matrix of density operator, warn if more than 16 qubits to force the user to set massive=True if they want such a large matrix.
`CircuitStateFn.to_instruction`()	Return Instruction corresponding to primitive.
`CircuitStateFn.to_legacy_op`([massive])	Attempt to return the Legacy Operator representation of the Operator.
`CircuitStateFn.to_matrix`([massive])	Return NumPy representation of the Operator.
`CircuitStateFn.to_matrix_op`([massive])	Return a `VectorStateFn` for this `StateFn`.
`CircuitStateFn.traverse`(convert_fn[, coeff])	Apply the convert_fn to the internal primitive if the primitive is an Operator (as in the case of `OperatorStateFn`).
`CircuitStateFn.__mul__`(other)	Overload `*` for Operator scalar multiplication.